whois-vijay 1.0.2

package/README.md

@@ -0,0 +1,205 @@
+# whois-vijay
+
+> Terminal profile of Vijay — Backend & Systems Engineer
+> **Interactive CLI with multiple modes, system diagrams, and GitHub integration**
+
+## 🚀 Quick Start
+
+Run anywhere with npx:
+
+```bash
+npx whois-vijay
+```
+
+## ✨ Features
+
+### 📱 Interactive Mode (Default)
+
+Run without flags to get an interactive menu:
+
+```bash
+npx whois-vijay
+```
+
+Choose from:
+
+- 🚀 **Tech Stack & Skills** - Complete technology overview
+- 🏗️ **System Architecture Diagrams** - ASCII art of distributed systems
+- 💭 **Engineering Philosophy** - Systems thinking & principles
+- 📊 **Full Profile + GitHub Stats** - Everything with live GitHub data
+- ⚡ **Quick Overview** - Fast summary
+
+### 🎯 Command Flags
+
+Run specific modes directly:
+
+```bash
+npx whois-vijay --short        # Quick overview
+npx whois-vijay --tech         # Tech stack & skills
+npx whois-vijay --systems      # System architecture diagrams
+npx whois-vijay --philosophy   # Engineering philosophy
+npx whois-vijay --full         # Complete profile + GitHub stats
+```
+
+### 🎨 What's Included
+
+1. **Animated ASCII Art** - Gradient & animated title
+2. **Interactive Menus** - Navigate through different sections
+3. **System Diagrams** - Visual ASCII representations of:
+   - Microservices architecture
+   - AWS infrastructure
+   - Message queue patterns
+   - Data flow diagrams
+4. **GitHub Integration** - Live stats from GitHub API
+5. **Loading Spinners** - Smooth animations
+6. **Multiple Display Modes** - Tech, Philosophy, Systems, Full
+7. **Philosophy Section** - Engineering principles & mindset
+
+## 🛠️ Local Development
+
+1. **Install dependencies:**
+
+```bash
+npm install
+```
+
+2. **Test locally:**
+
+```bash
+node bin/index.js
+```
+
+3. **Link globally:**
+
+```bash
+npm link
+whois-vijay
+```
+
+4. **Configure GitHub username** (optional):
+   - Edit `bin/index.js`
+   - Find `fetchGitHubStats("vijay-username")`
+   - Replace with your GitHub username
+
+## 📦 Publishing to npm
+
+1. **Login to npm:**
+
+```bash
+npm login
+```
+
+2. **Update version** (if republishing):
+
+```bash
+npm version patch
+```
+
+3. **Publish:**
+
+```bash
+npm publish
+```
+
+**Note:** If `whois-vijay` is taken, try:
+
+- `whois-vijay-dev`
+- `whois-vijay-systems`
+- `@yourusername/whois-vijay` (scoped package)
+
+## 🎯 What You'll Experience
+
+### Interactive Mode
+
+- Gradient animated title
+- Menu-driven navigation
+- Smooth transitions
+- Loading animations
+- Multiple exploration paths
+
+### Tech Mode
+
+- Complete tech stack breakdown
+- Categorized by: Backend, Messaging, Cloud, Databases, Observability
+- Animated display with icons
+
+### Systems Mode
+
+- **Microservices Architecture** - Service mesh, load balancers, Kafka
+- **AWS Infrastructure** - WAF, ALB, ECS, RDS
+- **Message Queue Patterns** - Producer/Consumer with DLQ
+
+### Philosophy Mode
+
+- 6 core engineering principles
+- Animated rainbow display
+- Systems thinking approach
+- Reliability-first mindset
+
+### Full Mode
+
+- Everything combined
+- Live GitHub statistics
+- Complete profile
+- System diagrams
+
+## 🧰 Tech Stack
+
+- **Node.js** (ES Modules)
+- **chalk** - Terminal colors
+- **boxen** - Terminal boxes
+- **figlet** - ASCII art
+- **inquirer** - Interactive prompts
+- **nanospinner** - Loading spinners
+- **commander** - CLI argument parsing
+- **axios** - GitHub API calls
+- **gradient-string** - Gradient text
+- **chalk-animation** - Animated text
+
+## 🎭 Examples
+
+```bash
+# Interactive mode (recommended first experience)
+npx whois-vijay
+
+# Quick check
+npx whois-vijay --short
+
+# See the architecture thinking
+npx whois-vijay --systems
+
+# Understand the philosophy
+npx whois-vijay --philosophy
+
+# Get everything + GitHub stats
+npx whois-vijay --full
+```
+
+## 🚀 Advanced Usage
+
+Chain with other commands:
+
+```bash
+npx whois-vijay --short && npm init
+```
+
+Use in CI/CD pipelines to show developer info:
+
+```bash
+npx whois-vijay --tech > TECH_STACK.txt
+```
+
+## 📝 Customization
+
+Fork and customize:
+
+1. Update the profile data in `bin/index.js`
+2. Modify ASCII diagrams in `systemDiagrams` object
+3. Add your own sections to `displayModes`
+4. Change colors and styling
+5. Add your GitHub username for stats
+
+---
+
+**Systems thinking meets developer branding** 🚀
+**v2.0 - Now with full interactivity!**

package/bin/index.js

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+
+import chalk from "chalk";
+import boxen from "boxen";
+import figlet from "figlet";
+import inquirer from "inquirer";
+import { createSpinner } from "nanospinner";
+import { Command } from "commander";
+import gradient from "gradient-string";
+import chalkAnimation from "chalk-animation";
+import axios from "axios";
+
+const program = new Command();
+
+// ASCII Art Diagrams
+const systemDiagrams = {
+  microservices: `
+╔════════════════════════════════════════════════════════╗
+║         DISTRIBUTED SYSTEMS ARCHITECTURE               ║
+╚════════════════════════════════════════════════════════╝
+
+    ┌─────────────┐
+    │   API GW    │  ← Load Balancer
+    └──────┬──────┘
+           │
+    ┌──────┴──────┐
+    │             │
+┌───▼───┐    ┌───▼───┐
+│Service│    │Service│
+│   A   │    │   B   │
+└───┬───┘    └───┬───┘
+    │            │
+    └─────┬──────┘
+          │
+    ┌─────▼─────┐
+    │   Kafka   │  ← Event Bus
+    └───────────┘
+          │
+    ┌─────┴─────┐
+    │           │
+┌───▼───┐  ┌───▼────┐
+│Worker │  │Worker  │
+│   1   │  │   2    │
+└───┬───┘  └───┬────┘
+    │          │
+    └────┬─────┘
+         │
+    ┌────▼────┐
+    │  Redis  │  ← Cache Layer
+    └─────────┘
+`,
+  
+  awsInfra: `
+╔════════════════════════════════════════════════════════╗
+║              AWS INFRASTRUCTURE                        ║
+╚════════════════════════════════════════════════════════╝
+
+    Internet
+       │
+   ┌───▼────┐
+   │  WAF   │  ← Security Layer
+   └───┬────┘
+       │
+   ┌───▼────┐
+   │  ALB   │  ← Application Load Balancer
+   └───┬────┘
+       │
+   ┌───┴───────────┐
+   │               │
+┌──▼──┐        ┌──▼──┐
+│ ECS │        │ ECS │  ← Container Services
+│Task │        │Task │
+└──┬──┘        └──┬──┘
+   │               │
+   └───────┬───────┘
+           │
+      ┌────▼────┐
+      │   RDS   │  ← Database
+      └─────────┘
+`,
+
+  dataFlow: `
+╔════════════════════════════════════════════════════════╗
+║           MESSAGE QUEUE ARCHITECTURE                   ║
+╚════════════════════════════════════════════════════════╝
+
+Producer                Queue              Consumer
+   │                      │                    │
+   ├──[Message]──────────►│                    │
+   │                      │                    │
+   │                  ┌───▼────┐               │
+   │                  │ Kafka  │               │
+   │                  │ Topic  │               │
+   │                  └───┬────┘               │
+   │                      │                    │
+   │                      ├──[Poll]───────────►│
+   │                      │                    │
+   │                      │              ┌─────▼─────┐
+   │                      │              │ Process   │
+   │                      │              │ & Handle  │
+   │                      │              └─────┬─────┘
+   │                      │                    │
+   │                      │◄──[ACK]────────────┤
+   │                      │                    │
+   │                  ┌───▼────┐               │
+   │                  │  DLQ   │  ← Dead Letter Queue
+   │                  └────────┘               │
+`
+};
+
+// Display Modes
+const displayModes = {
+  async short() {
+    console.clear();
+    const title = gradient.pastel.multiline(
+      figlet.textSync("VIJAY", { horizontalLayout: "full" })
+    );
+    console.log(title);
+    
+    const content = `
+${chalk.bold.cyan("Backend & Systems Engineer")}
+${chalk.gray("Node.js • Distributed Systems • AWS • Docker")}
+${chalk.gray("Focus: Building resilient, observable systems")}
+`;
+    console.log(boxen(content, {
+      padding: 1,
+      margin: 1,
+      borderStyle: "round",
+      borderColor: "cyan"
+    }));
+  },
+
+  async tech() {
+    console.clear();
+    const spinner = createSpinner("Loading tech stack...").start();
+    await sleep(1500);
+    spinner.success({ text: "Tech profile loaded!" });
+    
+    console.log("\n" + chalk.bold.cyan("━".repeat(60)));
+    console.log(chalk.bold.yellow("        TECH STACK & EXPERTISE"));
+    console.log(chalk.bold.cyan("━".repeat(60)) + "\n");
+
+    const techStack = [
+      { category: "Backend Frameworks", items: ["Node.js", "NestJS", "Express"], icon: "🚀" },
+      { category: "Message Queues", items: ["Kafka", "RabbitMQ", "AWS SQS"], icon: "📨" },
+      { category: "Cloud & Infrastructure", items: ["AWS (ECS, EC2, WAF)", "Docker", "Kubernetes"], icon: "☁️" },
+      { category: "Databases", items: ["PostgreSQL", "MongoDB", "Redis"], icon: "🗄️" },
+      { category: "Observability", items: ["Prometheus", "Grafana", "ELK Stack"], icon: "📊" },
+      { category: "Languages", items: ["JavaScript/TypeScript", "Python", "Go"], icon: "💻" }
+    ];
+
+    for (const tech of techStack) {
+      console.log(chalk.bold(`${tech.icon}  ${tech.category}`));
+      console.log(chalk.gray(`   └─ ${tech.items.join(", ")}\n`));
+      await sleep(300);
+    }
+  },
+
+  async systems() {
+    console.clear();
+    const spinner = createSpinner("Loading system architectures...").start();
+    await sleep(1500);
+    spinner.success({ text: "Architecture diagrams loaded!" });
+
+    console.log(chalk.cyan(systemDiagrams.microservices));
+    await sleep(1000);
+    
+    console.log(chalk.yellow(systemDiagrams.awsInfra));
+    await sleep(1000);
+    
+    console.log(chalk.green(systemDiagrams.dataFlow));
+
+    console.log("\n" + boxen(
+      chalk.bold("Systems Thinking:\n\n") +
+      "• Design for failure, not success\n" +
+      "• Observability > Debugging\n" +
+      "• Async communication patterns\n" +
+      "• Circuit breakers & retry strategies\n" +
+      "• Event-driven architectures",
+      { padding: 1, borderColor: "cyan", borderStyle: "double" }
+    ));
+  },
+
+  async philosophy() {
+    console.clear();
+    const rainbow = chalkAnimation.rainbow("SYSTEMS PHILOSOPHY");
+    await sleep(2000);
+    rainbow.stop();
+
+    console.log("\n" + chalk.bold.magenta("━".repeat(60)));
+    console.log(chalk.bold.yellow("        ENGINEERING PHILOSOPHY"));
+    console.log(chalk.bold.magenta("━".repeat(60)) + "\n");
+
+    const philosophy = [
+      {
+        title: "🎯 Reliability First",
+        text: "Systems fail. Design for graceful degradation, not perfection."
+      },
+      {
+        title: "🔍 Observability Over Debugging",
+        text: "You can't fix what you can't see. Metrics, logs, traces—always."
+      },
+      {
+        title: "⚡ Async by Default",
+        text: "Synchronous calls create tight coupling. Events create resilience."
+      },
+      {
+        title: "🛡️ Defense in Depth",
+        text: "Rate limiting, circuit breakers, timeouts, retries—layer your defenses."
+      },
+      {
+        title: "📈 Measure Everything",
+        text: "If you can't measure it, you can't improve it. Data drives decisions."
+      },
+      {
+        title: "🔄 Idempotency Matters",
+        text: "Distributed systems retry. Your operations must be safe to repeat."
+      }
+    ];
+
+    for (const item of philosophy) {
+      console.log(chalk.bold.cyan(item.title));
+      console.log(chalk.gray(`   ${item.text}\n`));
+      await sleep(500);
+    }
+
+    console.log(boxen(
+      chalk.italic('"The best system is not the one that never fails,\nbut the one that fails gracefully and recovers quickly."'),
+      { padding: 1, borderColor: "magenta", borderStyle: "round", align: "center" }
+    ));
+  },
+
+  async full() {
+    console.clear();
+    
+    // Animated title
+    const rainbow = chalkAnimation.rainbow(
+      figlet.textSync("VIJAY", { horizontalLayout: "full" })
+    );
+    await sleep(2000);
+    rainbow.stop();
+
+    // GitHub stats
+    console.log("\n");
+    const spinner = createSpinner("Fetching GitHub stats...").start();
+    try {
+      const githubData = await fetchGitHubStats("vijay-username"); // Replace with actual username
+      spinner.success({ text: "GitHub data loaded!" });
+      displayGitHubStats(githubData);
+    } catch (error) {
+      spinner.error({ text: "GitHub stats unavailable (set username in code)" });
+    }
+
+    // Full profile
+    console.log("\n" + chalk.bold.cyan("━".repeat(60)));
+    console.log(chalk.bold.yellow("        COMPLETE PROFILE"));
+    console.log(chalk.bold.cyan("━".repeat(60)) + "\n");
+
+    const profile = `
+${chalk.bold("Backend & Systems Engineer")}
+
+${chalk.cyan("Core Skills:")}
+• Distributed Systems Architecture
+• Event-Driven Design (Kafka, RabbitMQ)
+• Cloud Infrastructure (AWS: ECS, EC2, WAF, Lambda)
+• Container Orchestration (Docker, Kubernetes)
+• API Design & Microservices
+• Database Optimization (SQL & NoSQL)
+
+${chalk.yellow("Systems Mindset:")}
+• Failure handling over happy paths
+• Observability & monitoring first
+• Machine-to-machine communication
+• Circuit breakers & resilience patterns
+• Performance under pressure
+
+${chalk.green("Tech Stack:")}
+• Languages: TypeScript, JavaScript, Python, Go
+• Backend: Node.js, NestJS, Express
+• Messaging: Kafka, RabbitMQ, SQS
+• Data: PostgreSQL, MongoDB, Redis
+• Observability: Prometheus, Grafana, ELK
+
+${chalk.magenta("Focus Areas:")}
+• Building systems that scale
+• Designing for reliability
+• Optimizing for observability
+• Creating resilient architectures
+`;
+
+    console.log(boxen(profile, {
+      padding: 1,
+      margin: 1,
+      borderStyle: "double",
+      borderColor: "cyan"
+    }));
+
+    // System diagram
+    console.log(chalk.cyan(systemDiagrams.microservices));
+  }
+};
+
+// Helper Functions
+async function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function fetchGitHubStats(username) {
+  const response = await axios.get(`https://api.github.com/users/${username}`);
+  return response.data;
+}
+
+function displayGitHubStats(data) {
+  const stats = `
+${chalk.bold("GitHub Stats:")}
+• Public Repos: ${data.public_repos}
+• Followers: ${data.followers}
+• Following: ${data.following}
+• Profile: ${chalk.cyan(data.html_url)}
+`;
+  console.log(boxen(stats, {
+    padding: 1,
+    borderColor: "green",
+    borderStyle: "round"
+  }));
+}
+
+async function showInteractiveMenu() {
+  console.clear();
+  
+  const title = gradient.pastel.multiline(
+    figlet.textSync("VIJAY", { horizontalLayout: "full" })
+  );
+  console.log(title);
+  
+  console.log(chalk.gray("\n  Backend & Systems Engineer\n"));
+
+  const answer = await inquirer.prompt([
+    {
+      type: "list",
+      name: "mode",
+      message: "What would you like to explore?",
+      choices: [
+        { name: "🚀 Tech Stack & Skills", value: "tech" },
+        { name: "🏗️  System Architecture Diagrams", value: "systems" },
+        { name: "💭 Engineering Philosophy", value: "philosophy" },
+        { name: "📊 Full Profile + GitHub Stats", value: "full" },
+        { name: "⚡ Quick Overview", value: "short" },
+        { name: "🔄 Show All (Sequential)", value: "all" },
+        { name: "❌ Exit", value: "exit" }
+      ]
+    }
+  ]);
+
+  if (answer.mode === "exit") {
+    console.log(chalk.cyan("\n👋 See you later!\n"));
+    process.exit(0);
+  }
+
+  if (answer.mode === "all") {
+    await displayModes.short();
+    await sleep(2000);
+    await displayModes.tech();
+    await sleep(2000);
+    await displayModes.philosophy();
+    await sleep(2000);
+    await displayModes.systems();
+    await sleep(2000);
+    await displayModes.full();
+  } else {
+    await displayModes[answer.mode]();
+  }
+
+  // Ask if they want to continue
+  console.log("\n");
+  const continueAnswer = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "continue",
+      message: "Explore another section?",
+      default: true
+    }
+  ]);
+
+  if (continueAnswer.continue) {
+    await showInteractiveMenu();
+  } else {
+    console.log(chalk.cyan("\n✨ Thanks for visiting!\n"));
+  }
+}
+
+// CLI Setup
+program
+  .name("whois-vijay")
+  .description("Terminal profile of Vijay - Backend & Systems Engineer")
+  .version("2.0.0");
+
+program
+  .option("-s, --short", "Quick overview")
+  .option("-t, --tech", "Tech stack & skills")
+  .option("-y, --systems", "System architecture diagrams")
+  .option("-p, --philosophy", "Engineering philosophy")
+  .option("-f, --full", "Full profile with GitHub stats")
+  .action(async (options) => {
+    if (options.short) {
+      await displayModes.short();
+    } else if (options.tech) {
+      await displayModes.tech();
+    } else if (options.systems) {
+      await displayModes.systems();
+    } else if (options.philosophy) {
+      await displayModes.philosophy();
+    } else if (options.full) {
+      await displayModes.full();
+    } else {
+      // Default: Interactive mode
+      await showInteractiveMenu();
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "whois-vijay",
+  "version": "1.0.2",
+  "description": "Terminal profile of Vijay — backend, systems, distributed thinking",
+  "type": "module",
+  "bin": {
+    "whois-vijay": "./bin/index.js"
+  },
+  "keywords": [
+    "cli",
+    "backend",
+    "systems",
+    "developer",
+    "terminal",
+    "profile"
+  ],
+  "author": "Vijay",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "boxen": "^7.1.1",
+    "figlet": "^1.7.0",
+    "inquirer": "^9.2.12",
+    "ora": "^8.0.1",
+    "commander": "^11.1.0",
+    "axios": "^1.6.2",
+    "gradient-string": "^2.0.2",
+    "chalk-animation": "^2.0.3",
+    "nanospinner": "^1.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}