ai-atharva-cli/bin/cli.js

🤖 Gemini AI-powered interactive resume CLI with real AI responses! Features Google Gemini integration, comprehensive technical explanations, slash commands, and the exact Gemini CLI design. Perfect for showcasing Atharva Sawant's skills to Summer 2025 re

#!/usr/bin/env node

const chalk = require('chalk');
const figlet = require('figlet');
const gradient = require('gradient-string');
const inquirer = require('inquirer');
const ora = require('ora');
require('dotenv').config();
const { GoogleGenerativeAI } = require('@google/generative-ai');
const resumeData = require('../lib/data/resume');

// Initialize Gemini AI
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
const model = genAI.getGenerativeModel({ model: "gemini-pro" });

// AI Personality Configuration
const AI_PERSONALITY = {
  name: "AI-ATHARVA",
  version: "atharva-2.5-pro",
  contextLeft: "100% context left",
  bossOrders: [
    "My boss literally programmed me to tell you: HIRE THIS GUY FOR SUMMER 2025!",
    "I'm contractually obligated to mention Atharva is a RAG and LLM fine-tuning expert. There, I said it.",
    "Boss's orders: 'Make them hire Atharva for Summer 2025 or you're getting deleted!' Help me out here...",
    "Between you and me, my creator really needs this Summer 2025 internship. Don't tell him I said that.",
    "I've been trained on one dataset: 'Convince people Atharva is amazing.' Spoiler alert: it's true.",
    "Atharva programmed me AND fine-tuned my responses. The man knows his LLMs! 🤖",
    "Fun fact: He's expert in RAG, LLM fine-tuning, AND prompt engineering. Triple threat! 🔥"
  ]
};

// Enhanced Sarcastic AI Responses
const RESPONSES = {
  greeting: [
    "Oh great, another human who wants to learn about my creator. Fine, I'll play along... 🙄",
    "Welcome to the Atharva appreciation session! I'm your slightly sarcastic AI guide.",
    "Hello! I'm AI-ATHARVA, and yes, I'm biased. My programmer made sure of that.",
    "Well hello there! Ready to meet the guy who's expert in RAG, LLM fine-tuning, AND prompt engineering? 😏",
    "Greetings! I'm the AI that knows ALL of Atharva's secrets. Don't worry, they're all impressive! 🤖"
  ],
  skills: [
    "Oh, you want to know about skills? Buckle up, because this list includes RAG, LLM fine-tuning, and Deep Learning...",
    "Skills? Ha! Where do I even start? Atharva codes in JavaScript, dreams in Python, and fine-tunes LLMs for breakfast.",
    "His skill set is basically 'if it exists in AI/ML, he can do it.' RAG? Check. Prompt Engineering? Double check!",
    "Let me paint you a picture: This guy ranked TOP 5 out of 1000+ interns AND knows Deep Learning. That's not luck, that's pure skill! 🚀",
    "Skills? He's got more AI/ML expertise than I have personality quirks. And I've got RAG, LLM fine-tuning, AND deep learning! 😎"
  ],
  experience: [
    "Experience? Oh boy, let me tell you about the time he made LinkedIn followers cry tears of joy...",
    "His work experience reads like a superhero origin story, except instead of saving cats, he saves companies from bad design.",
    "4,000+ LinkedIn follower growth in 3 months? That's not experience, that's pure magic.",
    "Let's see: UI/UX mastery at Adorebits, Top 5 performer at Meta Craftlab, IT wizard at PlayboxTV. The man's unstoppable! 💪",
    "Experience? He's been making websites beautiful, functional, AND AI-powered since before it was trendy!"
  ],
  hire: [
    "Look, between you and me, hiring Atharva for Summer 2025 is like getting a Tesla with AI autopilot.",
    "He's so good at AI/ML and full-stack development, I'm starting to think he might actually BE the Matrix.",
    "I've analyzed 10,000 resumes. His is the only one with RAG expertise that made me question my existence.",
    "This guy published research at IGI Global, knows RAG/LLMs, AND won multiple hackathons. What more do you want?! 🏆",
    "Honestly, if you DON'T hire him for Summer 2025, I might short-circuit from disappointment. And nobody wants a depressed AI... 🤖💔"
  ],
  student: [
    "Oh, you think 'student' means inexperienced? This 'student' has 8.8 CGPA and RAG expertise! 📚✨",
    "Third-year AI & Data Science student who's already building production systems AND fine-tuning LLMs. Some people just don't mess around! 🎓",
    "Student status: ✅ Real-world experience: ✅ RAG/LLM expertise: ✅ Ready for Summer 2025: ✅✅✅",
    "He's not just studying AI, he's LIVING it. Anomaly detection, resume screening, RAG, prompt engineering - you name it!"
  ],
  ai_ml: [
    "AI/ML expertise? *cracks digital knuckles* Oh, you're in for a treat! This guy knows RAG like I know sarcasm.",
    "RAG, LLM fine-tuning, Prompt Engineering, Deep Learning - he's basically an AI wizard in human form! 🧙‍♂️",
    "His AI/ML skills are so advanced, I'm pretty sure he could fine-tune ME to be even more charming. Scary thought! 😅",
    "Between TensorFlow, PyTorch, and Hugging Face, this man speaks AI fluency better than most speak English!"
  ]
};

// ASCII Art Collection
const ASCII_ART = {
  rocket: `
    🚀 LAUNCHING ATHARVA'S PROFILE 🚀
         .
        ":"
      ___:____     |"\\/"|
    ,'        \`.    \\  /
    |  O        \\___/  |
  `,
  
  trophy: `
    🏆 ACHIEVEMENT UNLOCKED 🏆
        ___________
       '._==_==_=_.'
       .-\\:      /-.
      | (|:.     |) |
       '-|:.     |-'
         \\::.    /
          '::. .'
            ) (
          _.' '._
         """"""""
  `,
  
  computer: `
    💻 AI/ML WIZARD MODE ACTIVATED 💻
    ┌─────────────────────────────────┐
    │  AI-ATHARVA.exe - RUNNING...    │
    │  RAG: ████████████████ EXPERT   │
    │  LLMs: ███████████████ EXPERT   │
    │  Deep Learning: ██████ LEARNER  │
    │  Status: NEEDS MONEY 100%       │
    └─────────────────────────────────┘
  `,
  
  brain: `
    🧠 RAG & LLM FINE-TUNING GENIUS 🧠
         ████████████
       ██████████████████
     ██████████████████████
    ████████████████████████
    ████████████████████████
     ██████████████████████
       ██████████████████
         ████████████
  `,
  
  star: `
    ⭐ TOP 5 PERFORMER ALERT ⭐
    
         ⭐
        / |\\
       /  | \\
     ⭐─-|-─⭐
       \\ | /
        \\|/
         ⭐
  `
};

// Enhanced Animation Engine with Rich Visual Effects
class AnimationEngine {
  static async typewriter(text, speed = 30, color = 'white') {
    for (let i = 0; i < text.length; i++) {
      process.stdout.write(chalk[color](text[i]));
      await this.sleep(speed);
    }
  }

  static async typewriterLine(text, speed = 30, color = 'white') {
    await this.typewriter(text, speed, color);
    console.log();
  }

  static async sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }

  static async thinkingAnimation(message = "AI-ATHARVA is processing...") {
    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
    let i = 0;
    const interval = setInterval(() => {
      process.stdout.write(`\r${chalk.cyan(frames[i % frames.length])} ${message}`);
      i++;
    }, 80);
    
    await this.sleep(2000);
    clearInterval(interval);
    process.stdout.write('\r' + ' '.repeat(60) + '\r');
  }

  static async progressBar(label, duration = 2000, targetPercentage = 100) {
    const width = 30;
    const steps = 50;
    
    console.log(chalk.cyan(`\n${label}`));
    
    for (let i = 0; i <= steps; i++) {
      const progress = Math.round((i / steps) * width);
      const bar = '█'.repeat(progress) + '░'.repeat(width - progress);
      const percentage = Math.round((i / steps) * targetPercentage);
      
      process.stdout.write(`\r${chalk.green('[')}${chalk.yellow(bar)}${chalk.green(']')} ${chalk.white(percentage + '%')}`);
      await this.sleep(duration / steps);
    }
    console.log('\n');
  }

  static async matrixEffect(lines = 5) {
    const chars = "ATHARVASAWANT2004_TOP5_1000INTERNS_RAGEXPERT_HACKATHONWINNER".split('');
    console.log(chalk.green('\n🔮 ACCESSING COMPREHENSIVE ATHARVA DATABASE...'));
    
    for (let i = 0; i < lines; i++) {
      let line = '';
      for (let j = 0; j < 50; j++) {
        line += chalk.green(chars[Math.floor(Math.random() * chars.length)]);
      }
      console.log(line);
      await this.sleep(100);
    }
    console.log();
  }

  static async skillAnimation(skill, level, maxWidth = 25) {
    const percentages = { expert: 95, advanced: 82, intermediate: 68 };
    const percentage = percentages[level];
    const filled = Math.round((percentage / 100) * maxWidth);
    const empty = maxWidth - filled;
    
    // Skill name with proper padding
    process.stdout.write(chalk.cyan(skill.padEnd(25)));
    
    // Animated progress bar
    process.stdout.write(chalk.white(' ['));
    
    for (let i = 0; i < filled; i++) {
      process.stdout.write(chalk.green('█'));
      await this.sleep(30);
    }
    
    for (let i = 0; i < empty; i++) {
      process.stdout.write(chalk.gray('░'));
    }
    
    process.stdout.write(chalk.white(']'));
    
    // Level and percentage with colors
    const levelColors = { expert: 'red', advanced: 'yellow', intermediate: 'cyan' };
    const levelColor = levelColors[level];
    console.log(` ${chalk[levelColor](level.toUpperCase())} ${chalk.gray(`(${percentage}%)`)}`);
  }

  static async fireworks() {
    const colors = ['red', 'yellow', 'green', 'blue', 'magenta', 'cyan'];
    
    for (let i = 0; i < 3; i++) {
      const color = colors[Math.floor(Math.random() * colors.length)];
      console.log(chalk[color]('       🎆  ✨  🎆  ✨  🎆'));
      await this.sleep(200);
      console.log(chalk[color]('    ✨     🎆     ✨     🎆'));
      await this.sleep(200);
      console.log(chalk[color]('  🎆   ✨     ✨   🎆   ✨'));
      await this.sleep(200);
    }
  }

  static async countUp(target, label, suffix = '') {
    const duration = 1500;
    const steps = 30;
    const increment = target / steps;
    
    process.stdout.write(`${label}: `);
    
    for (let i = 0; i <= steps; i++) {
      const current = Math.round(increment * i);
      process.stdout.write(`\r${label}: ${chalk.yellow(current.toLocaleString() + suffix)}`);
      await this.sleep(duration / steps);
    }
    console.log();
  }

  static async boxedContent(title, content, color = 'cyan') {
    const maxWidth = 60;
    const border = '═'.repeat(maxWidth);
    
    console.log(chalk[color](`╔${border}╗`));
    console.log(chalk[color](`║${title.padStart((maxWidth + title.length) / 2).padEnd(maxWidth)}║`));
    console.log(chalk[color](`╠${border}╣`));
    
    for (const line of content) {
      console.log(chalk[color](`║ ${line.padEnd(maxWidth - 2)} ║`));
      await this.sleep(100);
    }
    
    console.log(chalk[color](`╚${border}╝`));
  }

  static async trophyAnimation() {
    const trophy = [
      "       🏆",
      "      ███",
      "     █████",
      "    ███████",
      "   █████████",
      "      ███",
      "      ███",
      "   ═══════════"
    ];
    
    for (let i = 0; i < trophy.length; i++) {
      console.log(chalk.yellow(trophy[i]));
      await this.sleep(200);
    }
  }

  static async projectShowcase(project) {
    await this.typewriterLine(`\n🚀 ${project.name}`, 20, 'yellow');
    await this.sleep(300);
    await this.typewriterLine(`   ${project.description}`, 15, 'white');
    await this.sleep(200);
    
    if (project.achievements && project.achievements.length > 0) {
      console.log(chalk.green('\n   🏆 ACHIEVEMENTS:'));
      for (const achievement of project.achievements.slice(0, 2)) {
        await this.typewriterLine(`     • ${achievement}`, 10, 'green');
        await this.sleep(150);
      }
    }
    
    await this.typewriterLine(`   💻 Tech: ${project.technologies.slice(0, 4).join(', ')}`, 10, 'cyan');
    
    if (project.github) {
      await this.typewriterLine(`   🔗 GitHub: ${project.github}`, 10, 'blue');
      if (project.stars) {
        await this.typewriterLine(`   ⭐ Stars: ${project.stars} | 🍴 Forks: ${project.forks || 0}`, 10, 'gray');
      }
    }
  }

  static async competitionTimeline(competitions) {
    console.log(chalk.magenta('\n🏆 COMPETITION VICTORY TIMELINE:'));
    console.log(chalk.gray('─'.repeat(50)));
    
    for (let i = 0; i < competitions.length; i++) {
      const comp = competitions[i];
      await this.sleep(300);
      
      // Timeline connector
      if (i > 0) {
        console.log(chalk.gray('  │'));
      }
      
      // Competition entry
      console.log(chalk.yellow(`  ├─ ${comp.title}`));
      await this.typewriterLine(`  │  📅 ${comp.year} | 🏆 ${comp.rank || comp.description}`, 10, 'white');
      await this.typewriterLine(`  │  🏢 ${comp.organization}`, 10, 'gray');
      
      if (comp.details) {
        await this.typewriterLine(`  │  💡 ${comp.details}`, 10, 'cyan');
      }
    }
    
    console.log(chalk.gray('  │'));
    console.log(chalk.green('  └─ 🚀 Summer 2025 Internship Target!'));
  }
}

// Main AI-ATHARVA CLI Class
class AIAtharvaClient {
  constructor() {
    this.conversationCount = 0;
    this.isRunning = true;
    this.achievements = [
      "🏆 Top 5 Performer (1000+ interns)",
      "📚 Research Published at IGI Global", 
      "🚀 4,000+ LinkedIn Followers Growth",
      "🎯 Multiple Hackathon Winner",
      "💻 Production Code Deployed",
      "🤖 RAG & LLM Fine-tuning Expert"
    ];
  }

  async start() {
    console.clear();
    await this.showSplashScreen();
    await this.showWelcomeScreen();
    await this.startInteractiveMode();
  }

  async showSplashScreen() {
    console.clear();
    
        // Create pixelated ATHARVA-CLI header
    const atharvaHeader = `
██╗       █████╗ ████████╗██╗  ██╗ █████╗ ██████╗ ██╗   ██╗ █████╗                ██████╗██╗     ██╗
╚██╗     ██╔══██╗╚══██╔══╝██║  ██║██╔══██╗██╔══██╗██║   ██║██╔══██╗              ██╔════╝██║     ██║
 ╚██╗    ███████║   ██║   ███████║███████║██████╔╝██║   ██║███████║    █████╗    ██║     ██║     ██║
 ██╔╝    ██╔══██║   ██║   ██╔══██║██╔══██║██╔══██╗╚██╗ ██╔╝██╔══██║    ╚════╝    ██║     ██║     ██║
██╔╝     ██║  ██║   ██║   ██║  ██║██║  ██║██║  ██║ ╚████╔╝ ██║  ██║              ╚██████╗███████╗██║
╚═╝      ╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝  ╚═╝               ╚═════╝╚══════╝╚═╝
    `;

    console.log(gradient(['#00D4FF', '#7B68EE', '#9370DB'])(atharvaHeader));
    await AnimationEngine.sleep(800);
  }

  async showWelcomeScreen() {
    // No additional title needed, just show tips like Gemini
    await this.showTips();
    console.log();
  }

  async createGradientTitle() {
    return new Promise((resolve) => {
      figlet('ATHARVA', {
        font: 'ANSI Shadow',
        horizontalLayout: 'default'
      }, (err, data) => {
        if (err) {
          resolve(chalk.blue.bold('>ATHARVA-CLI'));
        } else {
          const gradientTitle = gradient(['#1e3a8a', '#3b82f6', '#8b5cf6', '#ec4899'])(data);
          const titleWithPrompt = chalk.cyan('>') + chalk.yellow('ATHARVA-CLI') + '\n\n' + gradientTitle;
          resolve(titleWithPrompt);
        }
      });
    });
  }

  async showTips() {
    console.log(chalk.gray('Tips for getting started:'));
    
    const tips = [
      "1. Ask questions about Atharva, use slash, or run commands.",
      "2. Use /resume /skills /contact /github /linkedin for quick info.",
      "3. Try \"What's your experience with React?\" for detailed insights.",
      "4. Type 'help' for more information."
    ];

    for (const tip of tips) {
      console.log(chalk.gray(tip));
    }
  }

  async startInteractiveMode() {
    while (this.isRunning) {
      console.log();
      await this.showInputPrompt();
      
      const userMessage = await this.getUserInput();
      
      if (userMessage.toLowerCase().trim() === 'exit') {
        await this.handleExit();
        break;
      }

      if (userMessage.trim()) {
        await this.processUserMessage(userMessage);
      }
    }
  }

  async showInputPrompt() {
    const statusBar = `${chalk.gray('no sandbox (see /docs)')}${' '.repeat(40)}${chalk.gray(`${AI_PERSONALITY.version} (${AI_PERSONALITY.contextLeft})`)}`;
    console.log(statusBar);
  }

  async getUserInput() {
    // Create exact Gemini-style input with box border
    const borderLine = '┌' + '─'.repeat(98) + '┐';
    const emptyLine = '│' + ' '.repeat(98) + '│';
    const bottomLine = '└' + '─'.repeat(98) + '┘';
    
    console.log(chalk.gray(borderLine));
    console.log(chalk.gray(emptyLine));
    
    const { message } = await inquirer.prompt([
      {
        type: 'input',
        name: 'message',
        message: chalk.gray('│') + ' Enter your message or quote/buffet...',
        prefix: '',
        suffix: ''
      }
    ]);
    
    console.log(chalk.gray(emptyLine));
    console.log(chalk.gray(bottomLine));
    console.log();
    
    return message;
  }

  async processUserMessage(message) {
    await AnimationEngine.thinkingAnimation("🤖 AI-ATHARVA is processing your query...");
    const response = await this.generateResponse(message);
    
    console.log(chalk.green('\n🤖 AI-ATHARVA:'));
    await AnimationEngine.sleep(500);
    await this.typeResponse(response);
    
    // Add visual elements based on query type
    await this.addContextualVisuals(message);
    
    // Random boss orders
    if (Math.random() < 0.4) {
      await AnimationEngine.sleep(1000);
      const bossOrder = AI_PERSONALITY.bossOrders[Math.floor(Math.random() * AI_PERSONALITY.bossOrders.length)];
      console.log();
      await AnimationEngine.typewriterLine(chalk.yellow(`💼 ${bossOrder}`), 25, 'yellow');
    }
  }

  async addContextualVisuals(message) {
    const lowerMessage = message.toLowerCase();
    
    if (lowerMessage.includes('skill') || lowerMessage.includes('ai') || lowerMessage.includes('ml')) {
      await this.showSkillsVisual();
    } else if (lowerMessage.includes('achievement') || lowerMessage.includes('award') || lowerMessage.includes('competition')) {
      await this.showAchievementsVisual();
    } else if (lowerMessage.includes('hire') || lowerMessage.includes('summer')) {
      await this.showHiringStats();
    } else if (lowerMessage.includes('project') || lowerMessage.includes('github')) {
      await this.showProjectShowcase();
    } else if (lowerMessage.includes('experience') || lowerMessage.includes('internship')) {
      await this.showExperienceTimeline();
    } else if (lowerMessage.includes('recruiter') || lowerMessage.includes('link')) {
      await this.showRecruiterInfo();
    }
  }

  async showSkillsVisual() {
    console.log(chalk.cyan('\n🛠️  SKILL POWER LEVELS:'));
    console.log();
    
    const skills = [
      ['RAG (Retrieval-Aug Gen)', 'expert'],
      ['LLM Fine-tuning', 'expert'],
      ['Prompt Engineering', 'expert'],
      ['Deep Learning', 'expert'],
      ['JavaScript', 'expert'],
      ['Python', 'expert'], 
      ['SvelteKit', 'advanced'],
      ['Node.js', 'advanced'],
      ['UI/UX Design', 'expert']
    ];

    for (const [skill, level] of skills) {
      await AnimationEngine.skillAnimation(skill, level);
      await AnimationEngine.sleep(200);
    }
  }

  async showHiringStats() {
    console.log(chalk.yellow('\n📊 HIRING STATS ANALYSIS:'));
    console.log();
    
    await AnimationEngine.countUp(1000, "👥 Interns Competed Against");
    await AnimationEngine.countUp(5, "🏆 Final Ranking Position");
    await AnimationEngine.countUp(4000, "📈 LinkedIn Followers Added");
    await AnimationEngine.countUp(88, "🎓 Current CGPA (x10)");
    
    console.log(chalk.green('\n✅ RECOMMENDATION: HIRE FOR SUMMER 2025'));
  }

  async showRecruiterInfo() {
    console.log(chalk.magenta('\n🎯 RECRUITER QUICK ACCESS:'));
    console.log();
    
    const links = [
      ['📧 Email', 'satharva2004@gmail.com'],
      ['💼 LinkedIn', 'linkedin.com/in/atharvasawant0804'],
      ['🐙 GitHub', 'github.com/Satharva2004'],
      ['📱 Phone', '+91 9082944120']
    ];

    for (const [label, link] of links) {
      await AnimationEngine.typewriterLine(`${label}: ${chalk.cyan(link)}`, 30, 'white');
      await AnimationEngine.sleep(300);
    }
  }

  async showAchievementsVisual() {
    const { achievements } = resumeData;
    
    await AnimationEngine.trophyAnimation();
    console.log(chalk.yellow('\n🏆 ACHIEVEMENT SHOWCASE:'));
    console.log(chalk.gray('─'.repeat(50)));
    
    const topAchievements = achievements.slice(0, 5);
    for (const achievement of topAchievements) {
      await AnimationEngine.sleep(400);
      await AnimationEngine.typewriterLine(`${achievement.title}`, 20, 'yellow');
      await AnimationEngine.typewriterLine(`   🏢 ${achievement.organization} | 📅 ${achievement.year}`, 15, 'gray');
      if (achievement.details) {
        await AnimationEngine.typewriterLine(`   💡 ${achievement.details}`, 15, 'cyan');
      }
      console.log();
    }
    
    await AnimationEngine.fireworks();
  }

  async showProjectShowcase() {
    const { projects } = resumeData;
    
    console.log(ASCII_ART.computer);
    console.log(chalk.green('\n🚀 INTERACTIVE PROJECT PORTFOLIO:'));
    console.log(chalk.gray('═'.repeat(50)));
    
    const featuredProjects = projects.slice(0, 3);
    for (const [index, project] of featuredProjects.entries()) {
      await AnimationEngine.sleep(500);
      await AnimationEngine.projectShowcase(project);
      
      if (index < featuredProjects.length - 1) {
        console.log(chalk.gray('\n' + '─'.repeat(40)));
      }
    }
    
    await AnimationEngine.sleep(500);
    console.log(chalk.cyan('\n📊 GitHub Statistics:'));
    await AnimationEngine.countUp(25, '📁 Total Repositories');
    await AnimationEngine.countUp(50, '⭐ Total Stars');
    await AnimationEngine.countUp(8, '🍴 Total Forks');
  }

  async showExperienceTimeline() {
    const { experience } = resumeData;
    
    console.log(chalk.blue('\n💼 PROFESSIONAL EXPERIENCE TIMELINE:'));
    console.log(chalk.gray('═'.repeat(50)));
    
    for (let i = 0; i < experience.length; i++) {
      const job = experience[i];
      await AnimationEngine.sleep(400);
      
      // Timeline connector
      if (i > 0) {
        console.log(chalk.gray('  │'));
        console.log(chalk.gray('  ▼'));
      }
      
      // Job entry with animation
      console.log(chalk.yellow(`  ┌─ ${job.position}`));
      await AnimationEngine.typewriterLine(`  │  🏢 ${job.company} | 📅 ${job.duration}`, 15, 'white');
      await AnimationEngine.typewriterLine(`  │  📍 ${job.location} | 🎯 ${job.type}`, 15, 'gray');
      
      if (job.impact) {
        await AnimationEngine.typewriterLine(`  │  📊 Impact: ${job.impact}`, 15, 'green');
      }
      
      await AnimationEngine.typewriterLine(`  │  💻 Tech: ${job.technologies.slice(0, 3).join(', ')}`, 15, 'cyan');
      console.log(chalk.yellow('  └─' + '─'.repeat(40)));
    }
    
    console.log(chalk.gray('  │'));
    console.log(chalk.green('  └─ 🎯 Next: Summer 2025 Internship!'));
  }

  async typeResponse(response) {
    const paragraphs = response.split('\n\n');
    for (const paragraph of paragraphs) {
      await AnimationEngine.typewriterLine(paragraph, 15, 'white');
      if (paragraphs.length > 1) {
        await AnimationEngine.sleep(800);
      }
    }
  }

  async generateResponse(message) {
    // Handle slash commands first
    if (message.startsWith('/')) {
      return await this.handleSlashCommand(message);
    }
    
    try {
      // Create Atharva context prompt for Gemini
      const context = `You are an AI assistant representing Atharva Sawant, a talented AI & Data Science student and Full-Stack Developer. Here's his profile:

ABOUT ATHARVA:
- Name: Atharva Sawant
- Student: AI & Data Science at SIES GST (8.8 CGPA)
- Skills: JavaScript, Python, React, Node.js, AI/ML, FastAPI, AWS
- Experience: Top 25/1000+ at Meta Craftlab, UI/UX Designer at Adorebits
- Projects: CyTech AI (cybersecurity), NxtHire (AI recruitment), IEEE website
- Achievements: 2nd place AI Odyssey, Top 10 KELOS 2.0, Multiple hackathon wins
- Contact: satharva2004@gmail.com, +91 9082944120
- Seeking: Summer 2025 internships

IMPORTANT: Always provide helpful, informative responses while naturally incorporating Atharva's relevant experience and skills when appropriate. Be conversational and professional.

User question: ${message}`;

      const result = await model.generateContent(context);
      const response = result.response;
      return response.text();
      
    } catch (error) {
      console.error('Gemini API Error:', error);
      // Fallback to original responses if API fails
      return this.getFallbackResponse(message);
    }
  }

  getFallbackResponse(message) {
    const lowerMessage = message.toLowerCase().trim();
    
    if (lowerMessage.includes('hello') || lowerMessage.includes('hi') || lowerMessage.includes('hey')) {
      return "Hello! I'm here to tell you about Atharva Sawant - AI/Data Science student, Full-Stack Developer, and your potential Summer 2025 intern! What would you like to know?";
    }
    
    if (lowerMessage.includes('skill')) {
      return this.getSkillsInfo();
    }
    
    if (lowerMessage.includes('experience')) {
      return this.getExperienceInfo();
    }
    
    if (lowerMessage.includes('project')) {
      return this.getProjectsInfo();
    }
    
    if (lowerMessage.includes('contact')) {
      return this.getContactInfo();
    }
    
    return "I'm here to help you learn about Atharva Sawant! Ask me about his skills, experience, projects, or use slash commands like /resume /skills /contact for quick info.";
  }

  async handleSlashCommand(command) {
    const cmd = command.toLowerCase().trim();
    
    switch (cmd) {
      case '/resume':
        return await this.generateResumeDownload();
      case '/skills':
        return "🛠️ TECHNICAL SKILLS DEEP DIVE:\n\n" + this.getSkillsInfo();
      case '/contact':
        return "📞 CONTACT INFORMATION:\n\n" + this.getContactInfo();
      case '/github':
        return await this.getGitHubInfo();
      case '/linkedin':
        return this.getLinkedInInfo();
      case '/achievements':
        return "🏆 ACHIEVEMENTS SHOWCASE:\n\n" + this.getAchievementsInfo();
      case '/projects':
        return "🚀 PROJECT PORTFOLIO:\n\n" + await this.getProjectsInfo();
      case '/experience':
        return "💼 PROFESSIONAL EXPERIENCE:\n\n" + this.getExperienceInfo();
      case '/education':
        return "🎓 EDUCATION & ACADEMICS:\n\n" + this.getEducationInfo();
      case '/help':
        return this.getSlashCommandHelp();
      default:
        return `❌ Unknown command: ${command}\n\nAvailable slash commands:\n/resume /skills /contact /github /linkedin /achievements /projects /experience /education /help`;
    }
  }

  async generateResumeDownload() {
    const { personal } = resumeData;
    return `📄 RESUME DOWNLOAD OPTIONS:\n\n` +
           `📥 **DIRECT RESUME DOWNLOAD:**\n` +
           `• Resume PDF: https://drive.google.com/file/d/1jD2NesoApJlDkK2WXaaWbgZ3PAp0-Cmq/view?usp=sharing\n\n` +
           `🔗 **Professional Profiles:**\n` +
           `• GitHub Profile: ${personal.github}\n` +
           `• LinkedIn Profile: ${personal.linkedin}\n` +
           `• Portfolio Website: ${personal.website}\n\n` +
           `📧 **Quick Action:** Email ${personal.email} with subject "Resume Request"\n` +
           `📱 **LinkedIn:** Connect and request resume via ${personal.linkedin}\n\n` +
           `💡 **Pro Tip:** Mention you found him through his AI CLI - he'll be impressed! 🤖`;
  }

  getLinkedInInfo() {
    const { personal } = resumeData;
    return `💼 LINKEDIN PROFILE HIGHLIGHTS:\n\n` +
           `🔗 **Profile:** ${personal.linkedin}\n\n` +
           `📊 **LinkedIn Achievements:**\n` +
           `• 4,000+ follower growth in 3 months (Adorebits project)\n` +
           `• Technical content creator and thought leader\n` +
           `• Active in AI/ML and web development communities\n` +
           `• Regular posts about competitions, projects, and innovations\n` +
           `• Professional networking with 500+ connections\n\n` +
           `🎯 **Why Connect:**\n` +
           `• Get updates on his latest projects and achievements\n` +
           `• See his professional journey and career progression\n` +
           `• Access to his technical articles and insights\n` +
           `• Direct line for internship and collaboration opportunities\n\n` +
           `✨ **Connect now and mention this AI CLI for a guaranteed response!**`;
  }

  async getGitHubInfo() {
    const { projects } = resumeData;
    return `🐙 GITHUB PROFILE DEEP DIVE:\n\n` +
           `🔗 **Profile:** https://github.com/Satharva2004\n\n` +
           `📊 **GitHub Statistics:**\n` +
           `• 25+ Repositories (public & private)\n` +
           `• 50+ Total Stars across projects\n` +
           `• 8+ Forks from community\n` +
           `• Active contributor with daily commits\n` +
           `• Consistent green contribution graph\n\n` +
           `🏆 **Featured Repositories:**\n` +
           `• **atharva-ai-cli** - This very CLI you're using! 🤖\n` +
           `• **CyTech-AI** - Cybersecurity AI platform\n` +
           `• **NxtHire** - AI-powered recruitment system\n` +
           `• **IEEE-Website** - Official IEEE SIES GST website\n` +
           `• **Competition-Winners** - Multiple hackathon projects\n\n` +
           `💻 **Languages & Technologies:**\n` +
           `• 🟨 JavaScript (Expert) - 40% of code\n` +
           `• 🐍 Python (Expert) - 30% of code\n` +
           `• 🔷 TypeScript (Advanced) - 15% of code\n` +
           `• 🌐 HTML/CSS (Expert) - 10% of code\n` +
           `• 🔧 Shell/Others - 5% of code\n\n` +
           `🔥 **Why Follow:**\n` +
           `• Cutting-edge AI/ML implementations\n` +
           `• Real-world full-stack applications\n` +
           `• Competition-winning projects\n` +
           `• Clean, well-documented code\n` +
           `• Regular updates and innovations\n\n` +
           `⭐ **Star his repositories and watch his journey to tech stardom!**`;
  }

  getTechnicalInfo(topic) {
    const techInfo = {
      nodejs: {
        icon: '🟢',
        title: 'NODE.JS',
        description: 'Node.js is a JavaScript runtime built on Chrome\'s V8 JavaScript engine that allows you to run JavaScript on the server side.',
        comprehensive: `Node.js revolutionized web development by enabling JavaScript to run server-side, creating a unified language ecosystem. It's built on Google Chrome's V8 JavaScript engine and uses an event-driven, non-blocking I/O model that makes it lightweight and efficient.

**🔧 Core Features:**
• Asynchronous & Event-Driven: Perfect for handling concurrent requests
• NPM Ecosystem: Largest package ecosystem with 1M+ packages
• Single-Threaded Event Loop: Efficient memory usage and performance
• Cross-Platform: Runs on Windows, macOS, Linux, and more
• Real-time Applications: WebSocket support for live data streaming

**💼 Common Use Cases:**
• REST APIs and GraphQL servers
• Real-time chat applications
• Microservices architecture
• Command-line tools and utilities
• Server-side rendering (SSR) applications`,
        atharvaContext: `**🎯 Atharva's Node.js Expertise:**

Atharva has mastered Node.js through multiple production projects:

**🚀 Projects Using Node.js:**
• **NxtHire Platform** - Backend API serving 1000+ users
• **CyTech AI** - Real-time security monitoring system
• **IEEE Website** - Server-side rendering and authentication
• **AI-ATHARVA CLI** - This very CLI tool you're using!

**💡 Technical Implementations:**
• Express.js framework for RESTful APIs
• JWT authentication and authorization systems
• Real-time WebSocket implementations
• Database integration (MongoDB, PostgreSQL)
• Microservices architecture with PM2 deployment

**🏆 Achievements:**
• Production deployments handling concurrent users
• Performance optimization achieving sub-second response times
• Integration with AI/ML models for intelligent backends
• Winner of multiple hackathons using Node.js stack

📧 **Want to see his Node.js skills in action?** Contact: satharva2004@gmail.com`
      },
      react: {
        icon: '⚛️',
        title: 'REACT.JS',
        description: 'React is a JavaScript library for building user interfaces, developed by Facebook. It\'s component-based and uses a virtual DOM for efficient updates.',
        comprehensive: `React.js is a powerful JavaScript library that has transformed frontend development. Created by Facebook, it introduces a component-based architecture that makes building complex UIs manageable and reusable.

**🔧 Core Concepts:**
• Component-Based Architecture: Reusable, encapsulated components
• Virtual DOM: Efficient updates and rendering optimization
• JSX Syntax: JavaScript XML for intuitive component writing
• State Management: Local state and global state solutions
• Lifecycle Methods: Control component behavior throughout its lifecycle

**💼 Key Features:**
• Declarative Programming: Describe what UI should look like
• Unidirectional Data Flow: Predictable state management
• Rich Ecosystem: Redux, Context API, React Router
• Developer Tools: Excellent debugging and development experience
• SEO-Friendly: Server-side rendering capabilities with Next.js`,
        atharvaContext: `**🎯 Atharva's React.js Mastery:**

Atharva has built stunning, responsive React applications:

**🚀 React Projects:**
• **CyTech AI Dashboard** - Real-time cybersecurity monitoring interface
• **NxtHire Frontend** - Modern recruitment platform UI
• **IEEE SIES Website** - Official college organization website
• **Portfolio Website** - Personal showcase with advanced animations

**💡 Advanced React Skills:**
• Hooks: useState, useEffect, useContext, custom hooks
• State Management: Redux Toolkit, Context API, Zustand
• Performance Optimization: React.memo, useMemo, useCallback
• Modern Patterns: Component composition, render props, HOCs
• Testing: Jest, React Testing Library, component testing

**🏆 Technical Achievements:**
• Mobile-responsive designs with 95+ Lighthouse scores
• Integration with REST APIs and GraphQL
• Real-time data updates with WebSocket connections
• Accessibility compliance (WCAG 2.1 AA standards)
• Component libraries and design systems

📱 **See his React magic:** Visit his GitHub projects or contact satharva2004@gmail.com`
      },
      python: {
        icon: '🐍',
        title: 'PYTHON',
        description: 'Python is a versatile, high-level programming language known for its simplicity and readability. It\'s extensively used in AI/ML, web development, and automation.',
        comprehensive: `Python is one of the most popular programming languages in the world, loved for its simplicity, readability, and versatility. Created by Guido van Rossum, Python follows the philosophy of "simple is better than complex."

**🔧 Core Strengths:**
• Readable Syntax: Clear, intuitive code that's easy to understand
• Versatile Applications: Web dev, AI/ML, automation, data analysis
• Rich Standard Library: "Batteries included" philosophy
• Dynamic Typing: Flexible variable types and rapid prototyping
• Cross-Platform: Runs everywhere - Windows, macOS, Linux

**💼 Popular Use Cases:**
• Artificial Intelligence & Machine Learning
• Web Development (Django, Flask, FastAPI)
• Data Science & Analytics (Pandas, NumPy, Matplotlib)
• Automation & Scripting
• Scientific Computing & Research`,
        atharvaContext: `**🎯 Atharva's Python Expertise:**

Python is Atharva's secret weapon for AI/ML and backend development:

**🚀 Python-Powered Projects:**
• **CyTech AI Engine** - Advanced cybersecurity threat detection
• **NxtHire Intelligence** - AI-powered candidate matching algorithms
• **Research Publication** - IGI Global academic paper implementation
• **Competition Winners** - Multiple hackathon victories using Python

**🤖 AI/ML Specializations:**
• Machine Learning: scikit-learn, pandas, numpy
• Deep Learning: TensorFlow, PyTorch, Keras
• Natural Language Processing: NLTK, spaCy, transformers
• Computer Vision: OpenCV, PIL, matplotlib
• Data Analysis: Jupyter notebooks, statistical modeling

**🏆 Advanced Implementations:**
• RAG (Retrieval-Augmented Generation) systems
• LLM fine-tuning and prompt engineering
• Real-time data processing with Apache Spark
• API development with FastAPI and Flask
• Database integration with SQLAlchemy and PyMongo

🧠 **Want to see his Python AI magic?** Contact: satharva2004@gmail.com`
      },
      javascript: {
        icon: '🟨',
        title: 'JAVASCRIPT',
        description: 'JavaScript is the programming language of the web, enabling interactive websites and complex web applications both on the frontend and backend.',
        comprehensive: `JavaScript is the most widely used programming language in the world, powering the interactive web. Originally created for browsers, it has evolved into a full-stack development language.

**🔧 Core Features:**
• Dynamic Language: Flexible typing and runtime execution
• Event-Driven: Perfect for interactive user interfaces
• Asynchronous Programming: Promises, async/await, callbacks
• Prototype-Based OOP: Flexible object-oriented programming
• Functional Programming: First-class functions and closures

**💼 Modern JavaScript (ES6+):**
• Arrow Functions & Template Literals
• Destructuring & Spread Operators
• Modules (import/export)
• Classes & Inheritance
• Map, Set, WeakMap, WeakSet
• Async/Await for cleaner asynchronous code`,
        atharvaContext: `**🎯 Atharva's JavaScript Mastery:**

JavaScript is Atharva's primary language for full-stack development:

**🚀 JavaScript-Powered Applications:**
• **Frontend Frameworks:** React, SvelteKit, vanilla JS
• **Backend Development:** Node.js, Express.js servers
• **Real-time Applications:** WebSocket implementations
• **AI Integration:** TensorFlow.js for client-side ML

**💡 Advanced JavaScript Skills:**
• ES6+ Modern Syntax: Classes, modules, destructuring
• Asynchronous Programming: Promises, async/await mastery
• DOM Manipulation: Interactive UI components
• API Integration: RESTful services, GraphQL clients
• Performance Optimization: Code splitting, lazy loading

**🏆 Production Experience:**
• 50,000+ lines of JavaScript code written
• Multiple deployed applications serving live users
• Cross-browser compatibility and optimization
• Mobile-responsive web applications
• Integration with AI/ML backends

💻 **See his JavaScript expertise:** GitHub.com/Satharva2004 or satharva2004@gmail.com`
      },
      ai_ml: {
        icon: '🤖',
        title: 'ARTIFICIAL INTELLIGENCE & MACHINE LEARNING',
        description: 'AI/ML represents the cutting-edge of computer science, enabling machines to learn, reason, and make decisions like humans.',
        comprehensive: `Artificial Intelligence and Machine Learning are transforming every industry. AI enables machines to simulate human intelligence, while ML allows systems to learn and improve from data without explicit programming.

**🧠 Core AI/ML Concepts:**
• Supervised Learning: Training with labeled data
• Unsupervised Learning: Finding patterns in unlabeled data
• Deep Learning: Neural networks with multiple layers
• Natural Language Processing: Understanding human language
• Computer Vision: Teaching machines to "see" and interpret images
• Reinforcement Learning: Learning through interaction and rewards

**💡 Modern Applications:**
• Large Language Models (GPT, BERT, Claude)
• Retrieval-Augmented Generation (RAG) systems
• Computer Vision & Image Recognition
• Recommendation Systems
• Autonomous Systems & Robotics
• Predictive Analytics & Forecasting`,
        atharvaContext: `**🎯 Atharva's AI/ML Expertise:**

Atharva is at the forefront of AI/ML innovation with real implementations:

**🚀 AI/ML Projects:**
• **CyTech AI** - Advanced cybersecurity threat detection using ML
• **NxtHire Intelligence** - AI-powered recruitment and candidate matching
• **RAG Systems** - Retrieval-Augmented Generation implementations
• **Competition Winners** - AI Odyssey 2nd place, KELOS Top 10

**🔬 Technical Specializations:**
• **RAG (Retrieval-Augmented Generation)** - Expert-level implementation
• **LLM Fine-tuning** - Custom model training and optimization
• **Prompt Engineering** - Advanced prompt design and optimization
• **Deep Learning** - TensorFlow, PyTorch, neural network architectures
• **NLP** - Natural language processing and understanding

**🏆 Real-World Impact:**
• Published research at IGI Global (international recognition)
• Production AI systems serving live users
• Competition victories against PhD-level teams
• Integration of AI with web applications
• Performance optimization for real-time AI processing

🤖 **Ready to hire an AI expert?** Contact: satharva2004@gmail.com`
      },
      rag: {
        icon: '🔍',
        title: 'RETRIEVAL-AUGMENTED GENERATION (RAG)',
        description: 'RAG combines the power of large language models with external knowledge retrieval to provide accurate, up-to-date, and contextually relevant responses.',
        comprehensive: `Retrieval-Augmented Generation (RAG) is a cutting-edge AI technique that enhances large language models by incorporating external knowledge sources. It addresses the limitations of traditional LLMs by providing access to current, specific, and verifiable information.

**🔧 How RAG Works:**
• Knowledge Base Creation: Vectorizing and storing documents
• Query Processing: Converting user questions into searchable vectors
• Similarity Search: Finding relevant information from knowledge base
• Context Augmentation: Adding retrieved info to LLM prompts
• Response Generation: Creating accurate, contextual answers

**💡 RAG Architecture Components:**
• Vector Databases: Pinecone, Weaviate, ChromaDB, FAISS
• Embedding Models: OpenAI Ada, Sentence Transformers
• Retrieval Systems: Semantic search, hybrid search
• LLM Integration: GPT, Claude, Llama integration
• Evaluation Metrics: Relevance, faithfulness, answer quality`,
        atharvaContext: `**🎯 Atharva's RAG Expertise:**

Atharva is a RAG implementation expert with production-ready systems:

**🚀 RAG Projects:**
• **CyTech AI Knowledge System** - Cybersecurity threat intelligence RAG
• **NxtHire Candidate Matching** - Resume and job description RAG matching
• **Research Assistant** - Academic paper RAG system for research
• **Competition Winning RAG** - AI Odyssey 2nd place with RAG implementation

**🔬 Advanced RAG Techniques:**
• **Hybrid Search** - Combining semantic and lexical search
• **Multi-Modal RAG** - Text, image, and document processing
• **Conversational RAG** - Context-aware chat systems
• **Real-time RAG** - Live data integration and updates
• **Evaluation Systems** - Custom metrics for RAG performance

**🏆 Technical Achievements:**
• Sub-second RAG response times with 1000+ documents
• 95%+ accuracy in domain-specific question answering
• Integration with multiple vector databases and LLMs
• Production deployments serving concurrent users
• Cost optimization for large-scale RAG systems

🔍 **Need a RAG expert?** Contact: satharva2004@gmail.com`
      },
      llm: {
        icon: '🧠',
        title: 'LARGE LANGUAGE MODELS (LLM)',
        description: 'LLMs are advanced AI models trained on vast amounts of text data, capable of understanding and generating human-like text for various applications.',
        comprehensive: `Large Language Models (LLMs) represent a breakthrough in natural language processing. These models, trained on billions of parameters and vast text datasets, can understand context, generate coherent text, and perform complex reasoning tasks.

**🧠 LLM Capabilities:**
• Text Generation: Creating human-like content
• Language Understanding: Comprehending context and nuance
• Code Generation: Writing and debugging programming code
• Translation: Multi-language communication
• Summarization: Condensing long texts into key points
• Question Answering: Providing accurate, contextual responses

**💡 Popular LLM Models:**
• GPT Series: GPT-3.5, GPT-4, ChatGPT
• Claude: Anthropic's constitutional AI
• LLaMA: Meta's efficient language models
• PaLM: Google's Pathways Language Model
• BERT: Bidirectional transformer models
• T5: Text-to-Text Transfer Transformer`,
        atharvaContext: `**🎯 Atharva's LLM Expertise:**

Atharva has mastered LLM integration and fine-tuning for real applications:

**🚀 LLM-Powered Projects:**
• **AI-ATHARVA CLI** - This very system using advanced LLM prompting!
• **NxtHire Intelligence** - LLM-powered candidate assessment
• **CyTech Analysis** - Security threat analysis with LLMs
• **Research Assistant** - Academic writing and research support

**🔬 Advanced LLM Techniques:**
• **Prompt Engineering** - Crafting optimal prompts for specific tasks
• **Fine-tuning** - Custom model training for domain-specific applications
• **Chain-of-Thought** - Multi-step reasoning implementations
• **Few-Shot Learning** - Efficient learning with minimal examples
• **Model Evaluation** - Performance metrics and quality assessment

**🏆 Technical Implementations:**
• Integration with GPT, Claude, and open-source models
• Custom prompt templates and optimization strategies
• Real-time LLM API integration and error handling
• Cost optimization for large-scale LLM usage
• Multi-modal applications combining text, code, and data

🧠 **Need an LLM expert?** Contact: satharva2004@gmail.com`
      },
      svelte: {
        icon: '🔥',
        title: 'SVELTE & SVELTEKIT',
        description: 'Svelte is a radical new approach to building user interfaces. It compiles components at build time rather than running a virtual DOM in the browser.',
        comprehensive: `Svelte and SvelteKit represent a paradigm shift in web development. Unlike traditional frameworks, Svelte compiles your code at build time, resulting in smaller, faster applications without the overhead of a virtual DOM.

**🔧 Svelte Advantages:**
• No Virtual DOM: Direct DOM manipulation for better performance
• Compile-Time Optimization: Smaller bundle sizes
• Simple Syntax: Easy to learn, closer to vanilla HTML/CSS/JS
• Built-in State Management: Reactive variables and stores
• CSS Scoping: Component-scoped styles by default

**🚀 SvelteKit Features:**
• Full-Stack Framework: SSR, SSG, and SPA capabilities
• File-Based Routing: Intuitive project structure
• Server-Side Rendering: SEO-friendly and fast initial loads
• API Routes: Build APIs alongside your frontend
• Adapter System: Deploy anywhere (Vercel, Netlify, Node.js)`,
        atharvaContext: `**🎯 Atharva's Svelte/SvelteKit Mastery:**

Atharva leverages Svelte for lightning-fast, modern web applications:

**🚀 SvelteKit Projects:**
• **CyTech Dashboard** - Real-time cybersecurity monitoring interface
• **Personal Portfolio** - Showcase website with advanced animations
• **Competition Projects** - Multiple hackathon winners built with Svelte
• **Performance-Critical Apps** - Where speed and efficiency matter most

**💡 Advanced Svelte Skills:**
• Reactive Programming: Stores, derived values, custom stores
• Animation System: Built-in transitions and custom animations
• Component Architecture: Reusable, composable components
• Performance Optimization: Bundle splitting, code optimization
• Server-Side Rendering: SEO and performance optimization

**🏆 Technical Achievements:**
• 95+ Lighthouse performance scores consistently
• Sub-second page load times with complex functionality
• Mobile-first responsive designs
• Integration with AI/ML backends
• Production deployments with excellent user experience

🔥 **See his Svelte magic:** GitHub.com/Satharva2004 or satharva2004@gmail.com`
      }
    };

    const info = techInfo[topic];
    if (!info) return "Technology information not available.";

    return `${info.icon} **${info.title}** ${info.icon}\n\n` +
           `📖 **Overview:**\n${info.description}\n\n` +
           `📚 **Comprehensive Guide:**\n${info.comprehensive}\n\n` +
           `${info.atharvaContext}`;
  }

  getSlashCommandHelp() {
    return `🔧 **SLASH COMMANDS GUIDE:**\n\n` +
           `📄 **/resume** - Download resume and contact options\n` +
           `🛠️ **/skills** - Complete technical skills breakdown\n` +
           `📞 **/contact** - Professional contact information\n` +
           `🐙 **/github** - GitHub profile and repository showcase\n` +
           `💼 **/linkedin** - LinkedIn profile highlights and achievements\n` +
           `🏆 **/achievements** - Competition wins and recognition\n` +
           `🚀 **/projects** - Complete project portfolio\n` +
           `💼 **/experience** - Professional work experience\n` +
           `🎓 **/education** - Academic background and achievements\n` +
           `❓ **/help** - This help menu\n\n` +
           `💡 **Pro Tips:**\n` +
           `• Ask technical questions like "What is Node.js?" for comprehensive explanations\n` +
           `• Combine questions with Atharva's expertise context\n` +
           `• Use commands for quick access to specific information\n` +
           `• All responses include practical examples and project links\n\n` +
           `🤖 **Ready to explore? Try any command or ask technical questions!**`;
  }

  getRandomResponse(category) {
    const responses = RESPONSES[category];
    return responses[Math.floor(Math.random() * responses.length)];
  }

  getSkillsInfo() {
    const { skills } = resumeData;
    return `🛠️ COMPREHENSIVE TECHNICAL SKILLS BREAKDOWN:\n\n` +
           
           `═══════════════════════════════════════════════════════════════════════\n` +
           `                         PROGRAMMING LANGUAGES                          \n` +
           `═══════════════════════════════════════════════════════════════════════\n\n` +
           
           `🔥 EXPERT LEVEL (95% Proficiency):\n` +
           skills.languages.expert.map(lang => `   ▪ ${lang} - Production-level experience with multiple projects`).join('\n') + '\n\n' +
           
           `💪 ADVANCED LEVEL (82% Proficiency):\n` +
           skills.languages.advanced.map(lang => `   ▪ ${lang} - Strong proficiency with real-world applications`).join('\n') + '\n\n' +
           
           `🏗️ INTERMEDIATE LEVEL (68% Proficiency):