bytepet-cli 0.1.0

package/README.md

@@ -0,0 +1,77 @@
+# ⚡ bytepet-cli
+
+> A terminal pet that lives in your CLI — feed it, play with it, watch it grow.
+
+```
+  /\_____/\  
+ (  ^   ^  ) 
+ (  =^.^=  )        Pixel the Cat
+ (--m-m----)        Level 3 · 45/300 XP
+
+  ❤️  Health    ██████████  100%
+  🍖  Hunger    ███████░░░  70%
+  😊  Happiness ████████░░  80%
+  ⚡  Energy    █████░░░░░  50%
+
+  [f] Feed   [p] Play   [s] Sleep   [q] Quit
+```
+
+## Install
+
+```bash
+npm install -g bytepet-cli
+```
+
+## Usage
+
+```bash
+byte
+```
+
+That's it. Your pet remembers you between sessions — stats decay while you're away, so check in often!
+
+## Pets
+
+Choose from three pets on first run:
+- 🐱 **Cat** — curious and independent
+- 🐶 **Dog** — loyal and energetic  
+- 🐉 **Dragon** — rare and mysterious
+
+## Stats
+
+| Stat | Description |
+|------|-------------|
+| ❤️ Health | Drops if hunger or happiness hits 0 |
+| 🍖 Hunger | Decays over time — feed your pet! |
+| 😊 Happiness | Decays over time — play with your pet! |
+| ⚡ Energy | Decays over time — let your pet sleep! |
+| ⭐ XP / Level | Earned through feeding, playing, sleeping |
+
+## Actions
+
+| Key | Action | XP |
+|-----|--------|----|
+| `f` | Feed your pet | +10 XP |
+| `p` | Play Rock Paper Scissors | +5–15 XP |
+| `s` | Put your pet to sleep | +5 XP |
+| `q` | Quit | — |
+
+## Moods
+
+Your pet's ASCII art changes based on its mood:
+- 😊 **Happy** — all stats healthy
+- 🍖 **Hungry** — hunger below 20%
+- 😴 **Sleepy** — energy below 20%
+- 😢 **Sad** — happiness below 30%
+- 🤒 **Sick** — health below 20%
+
+## Roadmap
+
+- v0.1.0 — ✅ Core pet, 3 animals, 5 stats, RPS mini game
+- v0.2.0 — More mini games, pet evolution stages, rare pets
+- v0.3.0 — Pet accessories, backgrounds, seasonal events
+- v1.0.0 — Pro tier: multiple pets, cloud sync, pet sharing
+
+## License
+
+UNLICENSED — © 2025 Muhammad Talha Khan

package/bin/byte.js

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const readline = require('readline');
+const { PETS, getMood, getArt } = require('../lib/pets');
+const { load, save, applyDecay, createPet, addXP } = require('../lib/state');
+const rps = require('../lib/rps');
+
+// ── Colors ───────────────────────────────────────────────────────────────────
+const c = {
+  reset:   '\x1b[0m',
+  bold:    '\x1b[1m',
+  dim:     '\x1b[2m',
+  red:     '\x1b[31m',
+  green:   '\x1b[32m',
+  yellow:  '\x1b[33m',
+  blue:    '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan:    '\x1b[36m',
+  white:   '\x1b[37m',
+  gray:    '\x1b[90m',
+};
+
+const paint = (color, text) => `${color}${text}${c.reset}`;
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function bar(value, max = 100, len = 10) {
+  const filled = Math.round((value / max) * len);
+  const empty  = len - filled;
+  const color  = value > 60 ? c.green : value > 30 ? c.yellow : c.red;
+  return `${color}${'█'.repeat(filled)}${c.gray}${'░'.repeat(empty)}${c.reset}`;
+}
+
+function ask(rl, question) {
+  return new Promise(res => rl.question(question, ans => res(ans.trim())));
+}
+
+function clearScreen() {
+  process.stdout.write('\x1Bc');
+}
+
+function moodMessage(mood, name) {
+  const messages = {
+    happy:  `${name} is happy and energetic! 😊`,
+    hungry: `${name} is hungry... feed me! 🍖`,
+    sleepy: `${name} is really tired... 😴`,
+    sad:    `${name} needs some attention 😢`,
+    sick:   `${name} is not feeling well 🤒`,
+  };
+  return messages[mood];
+}
+
+// ── First run: pick pet ───────────────────────────────────────────────────────
+async function onboard() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  clearScreen();
+  console.log('');
+  console.log(paint(c.bold + c.cyan, '  🥚  Welcome to byte-cli!'));
+  console.log(paint(c.gray, '  Your terminal pet is waiting...\n'));
+
+  console.log(paint(c.bold, '  Choose your pet:\n'));
+  console.log(`  ${paint(c.cyan,    '[1]')} 🐱  Cat`);
+  console.log(`  ${paint(c.yellow,  '[2]')} 🐶  Dog`);
+  console.log(`  ${paint(c.magenta, '[3]')} 🐉  Dragon`);
+  console.log('');
+
+  let petType = null;
+  while (!petType) {
+    const choice = await ask(rl, '  Your choice: ');
+    if (choice === '1') petType = 'cat';
+    else if (choice === '2') petType = 'dog';
+    else if (choice === '3') petType = 'dragon';
+    else console.log(paint(c.red, '  Please pick 1, 2, or 3.\n'));
+  }
+
+  console.log('');
+  const name = await ask(rl, paint(c.bold, `  What will you name your ${PETS[petType].name}?\n  `) + '> ');
+  rl.close();
+
+  const petName = name || PETS[petType].name;
+  const state   = createPet(petName, petType);
+  save(state);
+
+  clearScreen();
+  console.log('');
+  console.log(paint(c.bold + c.green, `  🎉 ${petName} the ${PETS[petType].name} has been born!\n`));
+  console.log(paint(c.gray, '  Take good care of them. Come back often — they miss you when you\'re away.\n'));
+
+  await new Promise(res => setTimeout(res, 1500));
+  return state;
+}
+
+// ── Render main screen ────────────────────────────────────────────────────────
+function renderHome(state) {
+  const { name, petType, stats } = state;
+  const mood    = getMood(stats);
+  const art     = getArt(petType, stats);
+  const xpNeeded = stats.level * 100;
+
+  clearScreen();
+  console.log('');
+  console.log(paint(c.bold + c.cyan, '  ⚡ byte-cli\n'));
+
+  // ASCII art
+  art.forEach(line => console.log(paint(c.yellow, '  ' + line)));
+  console.log('');
+
+  // Name + level
+  console.log(`  ${paint(c.bold, name + ' the ' + PETS[petType].name)}  ${paint(c.gray, '·')}  ${paint(c.magenta, 'Level ' + stats.level)}  ${paint(c.gray, '·')}  ${paint(c.dim, stats.xp + '/' + xpNeeded + ' XP')}`);
+  console.log('');
+
+  // Stats
+  console.log(`  ❤️  Health    ${bar(stats.health)}  ${paint(c.gray, Math.round(stats.health) + '%')}`);
+  console.log(`  🍖  Hunger    ${bar(stats.hunger)}  ${paint(c.gray, Math.round(stats.hunger) + '%')}`);
+  console.log(`  😊  Happiness ${bar(stats.happiness)}  ${paint(c.gray, Math.round(stats.happiness) + '%')}`);
+  console.log(`  ⚡  Energy    ${bar(stats.energy)}  ${paint(c.gray, Math.round(stats.energy) + '%')}`);
+  console.log('');
+
+  // Mood message
+  console.log(`  ${paint(c.dim, moodMessage(mood, name))}`);
+  console.log('');
+
+  // Actions
+  console.log(paint(c.gray, '  ─────────────────────────────────────────'));
+  console.log(`  ${paint(c.cyan, '[f]')} Feed   ${paint(c.cyan, '[p]')} Play   ${paint(c.cyan, '[s]')} Sleep   ${paint(c.cyan, '[q]')} Quit`);
+  console.log('');
+}
+
+// ── Actions ───────────────────────────────────────────────────────────────────
+function feed(state) {
+  const s = { ...state, stats: { ...state.stats } };
+  const boost = Math.min(100 - s.stats.hunger, 30);
+  s.stats.hunger    = Math.min(100, s.stats.hunger + 30);
+  s.stats.happiness = Math.min(100, s.stats.happiness + 5);
+  const { state: newState, leveledUp } = addXP(s, 10);
+  return { state: newState, leveledUp, msg: `${paint(c.green, '🍖 Yum!')} Hunger +${boost}  XP +10` };
+}
+
+function sleep(state) {
+  const s = { ...state, stats: { ...state.stats } };
+  s.stats.energy    = Math.min(100, s.stats.energy + 40);
+  s.stats.health    = Math.min(100, s.stats.health + 5);
+  const { state: newState, leveledUp } = addXP(s, 5);
+  return { state: newState, leveledUp, msg: `${paint(c.blue, '💤 Zzz...')} Energy +40  XP +5` };
+}
+
+// ── Main loop ─────────────────────────────────────────────────────────────────
+async function main() {
+  let state = load();
+
+  if (!state) {
+    state = await onboard();
+  } else {
+    state = applyDecay(state);
+    save(state);
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+  let message = '';
+  let running = true;
+
+  renderHome(state);
+  if (message) console.log(`  ${message}\n`);
+
+  process.stdin.on('keypress', async (str, key) => {
+    if (!running) return;
+
+    if (key.name === 'q' || (key.ctrl && key.name === 'c')) {
+      running = false;
+      state.lastSeen = Date.now();
+      save(state);
+      rl.close();
+      clearScreen();
+      console.log('');
+      console.log(paint(c.cyan, `  👋 Goodbye! ${state.name} will miss you.\n`));
+      process.exit(0);
+    }
+
+    if (key.name === 'f') {
+      const result = feed(state);
+      state   = result.state;
+      message = result.msg;
+      if (result.leveledUp) message += paint(c.magenta + c.bold, `  🎉 LEVEL UP! Now level ${state.stats.level}!`);
+      save(state);
+      renderHome(state);
+      console.log(`  ${message}\n`);
+    }
+
+    if (key.name === 's') {
+      const result = sleep(state);
+      state   = result.state;
+      message = result.msg;
+      if (result.leveledUp) message += paint(c.magenta + c.bold, `  🎉 LEVEL UP! Now level ${state.stats.level}!`);
+      save(state);
+      renderHome(state);
+      console.log(`  ${message}\n`);
+    }
+
+    if (key.name === 'p') {
+      process.stdin.setRawMode(false);
+      rl.close();
+      running = false;
+
+      const result = await rps.play(state.name);
+
+      // Apply game results to stats
+      state.stats.happiness = Math.min(100, state.stats.happiness + result.happinessBoost);
+      state.stats.energy    = Math.max(0,   state.stats.energy    - result.energyCost);
+      const { state: newState, leveledUp } = addXP(state, result.xpEarned);
+      state = newState;
+
+      if (leveledUp) {
+        console.log(paint(c.magenta + c.bold, `  🎉 LEVEL UP! ${state.name} is now level ${state.stats.level}!\n`));
+        await new Promise(res => setTimeout(res, 1500));
+      }
+
+      save(state);
+
+      // Restart loop
+      running = true;
+      const newRl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      readline.emitKeypressEvents(process.stdin);
+      if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+      renderHome(state);
+
+      process.stdin.removeAllListeners('keypress');
+      process.stdin.on('keypress', async (str, key) => {
+        // re-attach same handler by restarting main — simplest approach
+        newRl.close();
+        process.stdin.setRawMode(false);
+        process.stdin.removeAllListeners('keypress');
+        main();
+      });
+    }
+  });
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/lib/pets.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const PETS = {
+  cat: {
+    emoji: '🐱',
+    name: 'Cat',
+    moods: {
+      happy: [
+        '  /\\_____/\\  ',
+        ' (  ^   ^  ) ',
+        ' (  =^.^=  ) ',
+        ' (--m-m----) ',
+      ],
+      hungry: [
+        '  /\\_____/\\  ',
+        ' (  -   -  ) ',
+        ' (  =o.o=  ) ',
+        ' (--m-m----) ',
+      ],
+      sleepy: [
+        '  /\\_____/\\  ',
+        ' (  -   -  ) ',
+        ' (  =-.-=  ) ',
+        ' (--m-m----) ',
+      ],
+      sad: [
+        '  /\\_____/\\  ',
+        ' (  T   T  ) ',
+        ' (  =v.v=  ) ',
+        ' (--m-m----) ',
+      ],
+      sick: [
+        '  /\\_____/\\  ',
+        ' (  x   x  ) ',
+        ' (  =@.@=  ) ',
+        ' (--m-m----) ',
+      ],
+    },
+  },
+  dog: {
+    emoji: '🐶',
+    name: 'Dog',
+    moods: {
+      happy: [
+        '  / \\_/ \\   ',
+        ' ( ^   ^ )  ',
+        ' (  o.o  )  ',
+        '  \\ ___/    ',
+        '   |   |    ',
+      ],
+      hungry: [
+        '  / \\_/ \\   ',
+        ' ( -   - )  ',
+        ' (  u.u  )  ',
+        '  \\ ___/    ',
+        '   |   |    ',
+      ],
+      sleepy: [
+        '  / \\_/ \\   ',
+        ' ( -   - )  ',
+        ' (  -.–  )  ',
+        '  \\ ___/    ',
+        '   |   |    ',
+      ],
+      sad: [
+        '  / \\_/ \\   ',
+        ' ( T   T )  ',
+        ' (  v.v  )  ',
+        '  \\ ___/    ',
+        '   |   |    ',
+      ],
+      sick: [
+        '  / \\_/ \\   ',
+        ' ( x   x )  ',
+        ' (  @.@  )  ',
+        '  \\ ___/    ',
+        '   |   |    ',
+      ],
+    },
+  },
+  dragon: {
+    emoji: '🐉',
+    name: 'Dragon',
+    moods: {
+      happy: [
+        '   / \\  / \\ ',
+        '  ( o  \\/  o)',
+        '  (   /\\   )',
+        ' __\\_/  \\_/__ ',
+        '(____________)',
+      ],
+      hungry: [
+        '   / \\  / \\ ',
+        '  ( -  \\/  -)',
+        '  (   /\\   )',
+        ' __\\_/  \\_/__ ',
+        '(____________)',
+      ],
+      sleepy: [
+        '   / \\  / \\ ',
+        '  ( -  \\/  -)',
+        '  (   -–   )',
+        ' __\\_/  \\_/__ ',
+        '(____________)',
+      ],
+      sad: [
+        '   / \\  / \\ ',
+        '  ( T  \\/  T)',
+        '  (   /\\   )',
+        ' __\\_/  \\_/__ ',
+        '(____________)',
+      ],
+      sick: [
+        '   / \\  / \\ ',
+        '  ( x  \\/  x)',
+        '  (   @~@  )',
+        ' __\\_/  \\_/__ ',
+        '(____________)',
+      ],
+    },
+  },
+};
+
+function getMood(stats) {
+  if (stats.health < 20) return 'sick';
+  if (stats.hunger < 20) return 'hungry';
+  if (stats.energy < 20) return 'sleepy';
+  if (stats.happiness < 30) return 'sad';
+  return 'happy';
+}
+
+function getArt(petType, stats) {
+  const mood = getMood(stats);
+  return PETS[petType].moods[mood];
+}
+
+module.exports = { PETS, getMood, getArt };

package/lib/rps.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const readline = require('readline');
+
+const CHOICES = ['rock', 'paper', 'scissors'];
+const EMOJI = { rock: '🪨', paper: '📄', scissors: '✂️' };
+
+const c = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  green:  '\x1b[32m',
+  red:    '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan:   '\x1b[36m',
+  gray:   '\x1b[90m',
+};
+
+function getResult(player, computer) {
+  if (player === computer) return 'draw';
+  if (
+    (player === 'rock'     && computer === 'scissors') ||
+    (player === 'paper'    && computer === 'rock')     ||
+    (player === 'scissors' && computer === 'paper')
+  ) return 'win';
+  return 'lose';
+}
+
+async function play(petName) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (q) => new Promise(res => rl.question(q, res));
+
+  console.log(`\n${c.cyan}${c.bold}  🎮 Rock Paper Scissors with ${petName}!${c.reset}\n`);
+  console.log(`${c.gray}  [1] Rock  [2] Paper  [3] Scissors  [q] Quit${c.reset}\n`);
+
+  let wins = 0, losses = 0, draws = 0;
+  let xpEarned = 0;
+  let playing = true;
+
+  while (playing) {
+    const input = (await ask(`  Your choice: `)).trim().toLowerCase();
+
+    if (input === 'q') { playing = false; break; }
+
+    const idx = parseInt(input) - 1;
+    if (isNaN(idx) || idx < 0 || idx > 2) {
+      console.log(`${c.yellow}  Invalid choice. Pick 1, 2, or 3.${c.reset}\n`);
+      continue;
+    }
+
+    const playerChoice   = CHOICES[idx];
+    const computerChoice = CHOICES[Math.floor(Math.random() * 3)];
+    const result         = getResult(playerChoice, computerChoice);
+
+    console.log(`\n  You: ${EMOJI[playerChoice]} ${playerChoice}`);
+    console.log(`  ${petName}: ${EMOJI[computerChoice]} ${computerChoice}\n`);
+
+    if (result === 'win') {
+      wins++;
+      xpEarned += 15;
+      console.log(`${c.green}${c.bold}  🎉 You win! +15 XP${c.reset}\n`);
+    } else if (result === 'lose') {
+      losses++;
+      xpEarned += 5;
+      console.log(`${c.red}  😅 ${petName} wins this round! +5 XP${c.reset}\n`);
+    } else {
+      draws++;
+      xpEarned += 8;
+      console.log(`${c.yellow}  🤝 Draw! +8 XP${c.reset}\n`);
+    }
+
+    const again = (await ask(`  Play again? [y/n]: `)).trim().toLowerCase();
+    if (again !== 'y') playing = false;
+    console.log('');
+  }
+
+  rl.close();
+
+  console.log(`${c.gray}  Score — Wins: ${wins} | Losses: ${losses} | Draws: ${draws}${c.reset}`);
+  console.log(`${c.cyan}  Total XP earned: +${xpEarned}${c.reset}\n`);
+
+  return { xpEarned, happinessBoost: wins * 8, energyCost: (wins + losses + draws) * 3 };
+}
+
+module.exports = { play };

package/lib/state.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const STATE_DIR = path.join(os.homedir(), '.byte-cli');
+const STATE_FILE = path.join(STATE_DIR, 'pet.json');
+
+const DECAY_RATES = {
+  hunger:    0.8,   // per hour
+  happiness: 0.5,
+  energy:    0.4,
+  health:    0.2,
+};
+
+function ensureDir() {
+  if (!fs.existsSync(STATE_DIR)) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+
+function load() {
+  ensureDir();
+  if (!fs.existsSync(STATE_FILE)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function save(state) {
+  ensureDir();
+  fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+function applyDecay(state) {
+  const now = Date.now();
+  const lastSeen = state.lastSeen || now;
+  const hoursElapsed = (now - lastSeen) / (1000 * 60 * 60);
+
+  if (hoursElapsed < 0.05) return state; // less than 3 mins, skip
+
+  const newState = { ...state, stats: { ...state.stats } };
+
+  for (const [stat, rate] of Object.entries(DECAY_RATES)) {
+    newState.stats[stat] = Math.max(0, newState.stats[stat] - rate * hoursElapsed);
+  }
+
+  // Health drops if hunger or happiness hits 0
+  if (newState.stats.hunger === 0 || newState.stats.happiness === 0) {
+    newState.stats.health = Math.max(0, newState.stats.health - 1 * hoursElapsed);
+  }
+
+  newState.lastSeen = now;
+  return newState;
+}
+
+function createPet(name, petType) {
+  return {
+    name,
+    petType,
+    stats: {
+      hunger:    80,
+      happiness: 80,
+      energy:    80,
+      health:    100,
+      xp:        0,
+      level:     1,
+    },
+    lastSeen: Date.now(),
+    born: Date.now(),
+  };
+}
+
+function addXP(state, amount) {
+  const newState = { ...state, stats: { ...state.stats } };
+  newState.stats.xp += amount;
+  const xpNeeded = newState.stats.level * 100;
+  if (newState.stats.xp >= xpNeeded) {
+    newState.stats.xp -= xpNeeded;
+    newState.stats.level += 1;
+    return { state: newState, leveledUp: true };
+  }
+  return { state: newState, leveledUp: false };
+}
+
+module.exports = { load, save, applyDecay, createPet, addXP };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "bytepet-cli",
+  "version": "0.1.0",
+  "description": "⚡ A terminal pet that lives in your CLI — feed it, play with it, watch it grow",
+  "main": "bin/byte.js",
+  "bin": {
+    "bytepet": "./bin/byte.js"
+  },
+  "scripts": {
+    "start": "node bin/byte.js"
+  },
+  "keywords": [
+    "cli",
+    "pet",
+    "tamagotchi",
+    "terminal",
+    "ascii",
+    "fun",
+    "game",
+    "developer"
+  ],
+  "author": "Muhammad Talha Khan",
+  "license": "UNLICENSED",
+  "private": false,
+  "engines": {
+    "node": ">=14"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/muhtalhakhan/bytepet-cli.git"
+  },
+  "homepage": "https://github.com/muhtalhakhan/bytepet-cli#readme",
+  "bugs": {
+    "url": "https://github.com/muhtalhakhan/bytepet-cli/issues"
+  }
+}