@cobanalitalha/claude-spinner 2.0.1 → 3.0.0

package/bin/claude-spinner.js

@@ -42,32 +42,28 @@ switch (command) {
   default: {
     console.log(`
   ┌──────────────────────────────────────────────────┐
-  │             claude-spinner  v2.0.0               │
-  │   Animated spinners for your Claude Code session │
+  │           claude-spinner  v3.0.0                 │
+  │   Dino game for your Claude Code session!        │
   └──────────────────────────────────────────────────┘
 
   COMMANDS
     install     Add hooks to ~/.claude/settings.json
     uninstall   Remove hooks from ~/.claude/settings.json
-    start       Start the spinner animation daemon
-    stop        Stop the spinner animation daemon
-    status      Show whether the daemon is running
+    start       Start the dino game
+    stop        Stop the dino game
+    status      Show whether the game is running
 
   QUICK START
     npm install -g claude-spinner
     claude-spinner install
-    # Then open Claude Code – a spinner appears automatically!
+    # Claude Code starts working → dino game appears at the bottom!
+    # Press SPACE or ENTER to jump over cacti.
 
   HOW IT WORKS
-    • Draws an animated spinner in the top-right corner of
-      your terminal using /dev/tty (never interferes with output).
-    • A random animation is chosen each session:
-        coffee  – steam rising from a cup
-        rocket  – exhaust flame pulsing beneath a rocket
-        clock   – arrow hand spinning around a dial
-        ball    – ball bouncing inside a box
-    • Starts automatically when Claude uses a tool and stops
-      when Claude finishes responding.
+    • When Claude uses a tool, a dino game launches at the bottom
+      of your terminal. Use SPACE to jump over cacti.
+    • When Claude finishes responding, the game stops automatically.
+    • Score increases over time – how high can you get?
 `);
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cobanalitalha/claude-spinner",
-  "version": "2.0.1",
-  "description": "Animated spinners for your Claude Code session",
+  "version": "3.0.0",
+  "description": "Play a dino game while Claude Code is thinking",
   "bin": {
     "claude-spinner": "bin/claude-spinner.js"
   },
@@ -16,8 +16,8 @@
     "claude",
     "claude-code",
     "terminal",
-    "animation",
-    "spinner",
+    "game",
+    "dino",
     "hooks"
   ],
   "author": "Ali Talha ÇOBAN",

package/src/daemon.js

@@ -1,21 +1,5 @@
 'use strict';
 
-/**
- * daemon.js
- *
- * Two responsibilities:
- *   1. Exported API: start() / stop() – called from the CLI to manage the daemon process.
- *   2. Daemon main loop – runs when this file is the entry point with the --daemon flag.
- *
- * KEY DESIGN NOTE
- * ───────────────
- * The daemon is spawned with `detached: true`, which means it loses its controlling
- * terminal and cannot open /dev/tty.  We work around this by resolving the real TTY
- * device path (e.g. /dev/ttys003 on macOS, /dev/pts/2 on Linux) *before* detaching
- * and passing it via the SPINNER_TTY environment variable.  A detached process can still
- * open a specific device node by path as long as it has permission.
- */
-
 const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
@@ -24,9 +8,7 @@ const { spawn, execSync } = require('child_process');
 const PID_FILE   = path.join(os.tmpdir(), 'claude-spinner.pid');
 const DAEMON_ARG = '--daemon';
 
-// ─────────────────────────────────────────────────────────────
-// Public API
-// ─────────────────────────────────────────────────────────────
+// ── Helpers ───────────────────────────────────────────────────────────────────
 
 function isAlive(pid) {
   try { process.kill(pid, 0); return true; } catch { return false; }
@@ -36,7 +18,7 @@ function readPid() {
   try { return parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10); } catch { return null; }
 }
 
-/** Find the real TTY device path for the current process. Returns null if not a TTY. */
+/** Resolve the real TTY device path (e.g. /dev/ttys003) for the current process tree. */
 function resolveTTY() {
   // 1. Direct check – works when hook stdin is still connected to the terminal
   try {
@@ -44,44 +26,43 @@ function resolveTTY() {
     if (out && out !== 'not a tty' && fs.existsSync(out)) return out;
   } catch {}
 
-  // 2. Walk up the process tree looking for a parent that owns a TTY.
-  //    Claude Code itself always runs in a real terminal, so one of the
-  //    ancestor processes will have a TTY even if the hook's stdio is piped.
+  // 2. Walk up the process tree – Claude Code always runs in a real terminal
   try {
     let pid = process.ppid;
     for (let depth = 0; depth < 5 && pid > 1; depth++) {
       const ttyName = execSync(`ps -o tty= -p ${pid} 2>/dev/null`, { encoding: 'utf8' }).trim();
       if (ttyName && ttyName !== '??' && ttyName !== '?') {
-        // macOS: "s003" → "/dev/ttys003"  |  Linux: "pts/2" → "/dev/pts/2"
-        const ttyPath = ttyName.startsWith('/')   ? ttyName
+        const ttyPath = ttyName.startsWith('/')    ? ttyName
                       : ttyName.startsWith('pts/') ? `/dev/${ttyName}`
                       : ttyName.startsWith('tty')  ? `/dev/${ttyName}`
                       : `/dev/tty${ttyName}`;
         if (fs.existsSync(ttyPath)) return ttyPath;
       }
-      // Move up one level
       const ppid = execSync(`ps -o ppid= -p ${pid} 2>/dev/null`, { encoding: 'utf8' }).trim();
       pid = parseInt(ppid, 10);
       if (!pid || isNaN(pid)) break;
     }
   } catch {}
 
-  return null; // not a supported environment – fail silently
+  return null;
 }
 
+// ── Public API ────────────────────────────────────────────────────────────────
+
 function start() {
   const pid = readPid();
   if (pid && isAlive(pid)) return; // already running
 
   const ttyPath = resolveTTY();
-  if (!ttyPath) return; // not a TTY environment – silently do nothing
+  if (!ttyPath) return; // not a TTY environment – fail silently
 
   const cols = (process.stdout.columns || 80).toString();
+  const rows = (process.stdout.rows    || 24).toString();
 
   const child = spawn(process.execPath, [__filename, DAEMON_ARG], {
     detached: true,
     stdio: 'ignore',
-    env: { ...process.env, SPINNER_TTY: ttyPath, SPINNER_COLS: cols },
+    env: { ...process.env, SPINNER_TTY: ttyPath, SPINNER_COLS: cols, SPINNER_ROWS: rows },
   });
   child.unref();
 
@@ -97,80 +78,14 @@ function stop() {
 
 module.exports = { start, stop };
 
-// ─────────────────────────────────────────────────────────────
-// Daemon entry point
-// ─────────────────────────────────────────────────────────────
+// ── Daemon entry point ────────────────────────────────────────────────────────
 
 if (require.main === module && process.argv.includes(DAEMON_ARG)) {
-  runDaemon().catch(() => process.exit(1));
-}
+  const ttyPath  = process.env.SPINNER_TTY;
+  const termRows = parseInt(process.env.SPINNER_ROWS || '24', 10);
 
-// ─────────────────────────────────────────────────────────────
-// Daemon implementation
-// ─────────────────────────────────────────────────────────────
-
-async function runDaemon() {
-  const animations = require('./animations');
-  const keys = Object.keys(animations);
-  const anim = animations[keys[Math.floor(Math.random() * keys.length)]];
-
-  const ttyPath = process.env.SPINNER_TTY;
   if (!ttyPath) process.exit(1);
 
-  let ttyFd;
-  try {
-    ttyFd = fs.openSync(ttyPath, 'r+');
-  } catch {
-    process.exit(1);
-  }
-
-  const cols   = parseInt(process.env.SPINNER_COLS || '80', 10);
-  const col    = Math.max(1, cols - anim.width + 1);
-  const HEIGHT = anim.frames[0].length;
-
-  function writeTTY(str) {
-    try { fs.writeSync(ttyFd, str); } catch {}
-  }
-
-  /** Draw a frame at the fixed top-right position without disturbing Claude's cursor. */
-  function draw(frame) {
-    let buf = '\x1b7'; // DECSC: save cursor
-    for (let i = 0; i < frame.length; i++) {
-      buf += `\x1b[${i + 1};${col}H${frame[i]}`;
-    }
-    buf += '\x1b8'; // DECRC: restore cursor
-    writeTTY(buf);
-  }
-
-  /** Erase the spinner area on exit. */
-  function clear() {
-    const blank = ' '.repeat(anim.width + 2);
-    let buf = '\x1b7';
-    for (let i = 0; i < HEIGHT; i++) {
-      buf += `\x1b[${i + 1};${col}H${blank}`;
-    }
-    buf += '\x1b8';
-    writeTTY(buf);
-  }
-
-  function sleep(ms) {
-    return new Promise(r => setTimeout(r, ms));
-  }
-
-  // Graceful shutdown: clear the spinner then exit.
-  process.on('SIGTERM', () => {
-    clear();
-    try { fs.unlinkSync(PID_FILE); } catch {}
-    process.exit(0);
-  });
-
-  // ── Animation loop ──────────────────────────────────────────
-  let frameIdx = 0;
-  draw(anim.frames[0]);
-
-  while (true) {
-    await sleep(anim.intervalMs);
-    frameIdx = (frameIdx + 1) % anim.frames.length;
-    draw(anim.frames[frameIdx]);
-  }
+  const { runGame } = require('./game');
+  runGame(ttyPath, termRows);
 }

package/src/game.js

@@ -0,0 +1,249 @@
+'use strict';
+
+const fs           = require('fs');
+const { execSync } = require('child_process');
+
+// ── ANSI helpers ──────────────────────────────────────────────────────────────
+function pos(row, col) { return `\x1b[${row};${col}H`; }
+const SAVE   = '\x1b7';
+const REST   = '\x1b8';
+const HIDE_C = '\x1b[?25l';
+const SHOW_C = '\x1b[?25h';
+const CYAN   = (s) => `\x1b[36m${s}\x1b[0m`;
+const GREEN  = (s) => `\x1b[32m${s}\x1b[0m`;
+const YELLOW = (s) => `\x1b[33m${s}\x1b[0m`;
+const RED    = (s) => `\x1b[31m${s}\x1b[0m`;
+const DIM    = (s) => `\x1b[2m${s}\x1b[0m`;
+const BOLD   = (s) => `\x1b[1m${s}\x1b[0m`;
+
+// ── Game constants ────────────────────────────────────────────────────────────
+const GAME_W  = 60;   // game area width (columns)
+const GAME_H  = 10;   // game area height (rows)
+const GROUND  = 7;    // row (within game area, 0-indexed) where dino feet rest
+const DINO_X  = 6;    // dino column (0-indexed within game area)
+const GRAVITY = 0.8;
+const JUMP_V  = -3.2;
+const TICK_MS = 100;  // ms per game tick
+
+// ── Sprites ───────────────────────────────────────────────────────────────────
+// Dino: 3 cols wide [DINO_X-1 .. DINO_X+1], 3 rows tall
+//   head: round(dinoY)-2 | body: round(dinoY)-1 | feet: round(dinoY)
+const DINO_RUN = [
+  [' O ', '/|\\', '/ \\'],  // frame 0 – feet down
+  [' O ', '/|\\', '/\\ '],  // frame 1 – feet lifted
+];
+const DINO_DEAD = [' X ', '/|\\', '   '];
+
+// Cactus: 1 col wide, 3 rows tall; bottom at GROUND, top at GROUND-2
+const CACTUS = ['|', '|', '^'];
+
+// ── Game state ────────────────────────────────────────────────────────────────
+let dinoY      = GROUND;
+let dinoVy     = 0;
+let obstacles  = [];   // [{x: float}]
+let score      = 0;
+let tick       = 0;
+let dead       = false;
+let legAnim    = 0;    // 0 or 1
+let jumpQueued = false;
+let nextSpawn  = 30;   // ticks until next obstacle
+
+// ── TTY ───────────────────────────────────────────────────────────────────────
+let ttyFd;
+let ttyPath;
+let startRow;   // terminal row where game area begins (1-indexed)
+const ibuf = Buffer.alloc(4);
+
+function writeTTY(str) {
+  try { fs.writeSync(ttyFd, str); } catch {}
+}
+
+function pollInput() {
+  try {
+    const n = fs.readSync(ttyFd, ibuf, 0, 4, null);
+    if (n > 0 && (ibuf[0] === 0x20 || ibuf[0] === 0x0d)) {
+      jumpQueued = true;  // space or enter
+    }
+  } catch {}
+}
+
+// ── Update ────────────────────────────────────────────────────────────────────
+function update() {
+  if (dead) return;
+
+  tick++;
+  score = Math.floor(tick * 0.5);
+
+  // Jump
+  if (jumpQueued) {
+    if (dinoY >= GROUND - 0.5) dinoVy = JUMP_V;
+    jumpQueued = false;
+  }
+
+  // Physics
+  dinoVy += GRAVITY;
+  dinoY  += dinoVy;
+  if (dinoY >= GROUND) { dinoY = GROUND; dinoVy = 0; }
+
+  // Leg animation (only while on ground)
+  if (dinoY >= GROUND - 0.5) legAnim = Math.floor(tick / 4) % 2;
+
+  // Obstacle speed increases with score
+  const speed = 1 + Math.floor(score / 30) * 0.2;
+
+  // Move obstacles
+  for (const o of obstacles) o.x -= speed;
+  obstacles = obstacles.filter(o => o.x > -3);
+
+  // Spawn new obstacle
+  nextSpawn--;
+  if (nextSpawn <= 0) {
+    obstacles.push({ x: GAME_W - 1 });
+    nextSpawn = Math.floor(25 + Math.random() * 20);
+  }
+
+  // Collision detection
+  // Cactus hitbox: col ox, rows [GROUND-2 .. GROUND]
+  // Dino hitbox  : cols [DINO_X-1 .. DINO_X+1], rows [dy-2 .. dy]
+  // Dino clears cactus when dy < GROUND-2
+  const dy = Math.round(dinoY);
+  for (const o of obstacles) {
+    const ox = Math.round(o.x);
+    if (ox >= DINO_X - 1 && ox <= DINO_X + 1 && dy >= GROUND - 2) {
+      dead = true;
+      break;
+    }
+  }
+}
+
+// ── Render ────────────────────────────────────────────────────────────────────
+function render() {
+  // Build a plain character grid
+  const grid = Array.from({ length: GAME_H }, () => Array(GAME_W).fill(' '));
+  // Color tags per cell: 'G'=green(dino) 'Y'=yellow(cactus) ' '=plain 'D'=dim
+  const ctag = Array.from({ length: GAME_H }, () => Array(GAME_W).fill(' '));
+
+  // Row 0: score / hint
+  const scoreStr = `Score: ${String(score).padStart(4, '0')}`;
+  const hint     = dead ? 'GAME OVER – Claude is still working...' : 'SPACE to jump';
+  const gap      = GAME_W - scoreStr.length - hint.length;
+  const header   = scoreStr + ' '.repeat(Math.max(1, gap)) + hint;
+  for (let i = 0; i < Math.min(header.length, GAME_W); i++) grid[0][i] = header[i];
+
+  // Ground line (row GROUND+1 = 8)
+  for (let x = 0; x < GAME_W; x++) { grid[GROUND + 1][x] = '\u2500'; ctag[GROUND + 1][x] = 'D'; }
+
+  // Obstacles (cactus)
+  for (const o of obstacles) {
+    const ox = Math.round(o.x);
+    if (ox < 0 || ox >= GAME_W) continue;
+    for (let h = 0; h < 3; h++) {
+      const r = GROUND - 2 + h;
+      if (r >= 0 && r < GAME_H) { grid[r][ox] = CACTUS[h]; ctag[r][ox] = 'Y'; }
+    }
+  }
+
+  // Dino
+  const dy     = Math.round(dinoY);
+  const sprite = dead ? DINO_DEAD : DINO_RUN[legAnim];
+  for (let sr = 0; sr < 3; sr++) {
+    const r = dy - 2 + sr;
+    if (r < 0 || r >= GAME_H) continue;
+    for (let sc = 0; sc < 3; sc++) {
+      const c = DINO_X - 1 + sc;
+      if (c >= 0 && c < GAME_W) {
+        grid[r][c] = sprite[sr][sc];
+        ctag[r][c] = dead ? 'R' : 'G';
+      }
+    }
+  }
+
+  // Compose ANSI output (save cursor → draw → restore cursor)
+  let buf = SAVE + HIDE_C;
+  for (let r = 0; r < GAME_H; r++) {
+    buf += pos(startRow + r, 1);
+    if (r === 0) {
+      // Score row: cyan header
+      buf += CYAN(grid[0].join(''));
+    } else {
+      // Build row with per-cell coloring
+      let line = '';
+      for (let c = 0; c < GAME_W; c++) {
+        const ch = grid[r][c];
+        switch (ctag[r][c]) {
+          case 'G': line += GREEN(ch);  break;
+          case 'Y': line += YELLOW(ch); break;
+          case 'R': line += RED(ch);    break;
+          case 'D': line += DIM(ch);    break;
+          default:  line += ch;
+        }
+      }
+      buf += line;
+    }
+  }
+  buf += REST;
+  writeTTY(buf);
+}
+
+// ── Setup / teardown ──────────────────────────────────────────────────────────
+function setup(ttyPathArg, termRows) {
+  ttyPath  = ttyPathArg;
+  ttyFd    = fs.openSync(ttyPath, 'r+');
+  startRow = Math.max(1, termRows - GAME_H - 1);
+
+  // Set TTY to raw mode: keypresses arrive immediately, VMIN=0 VTIME=0 = non-blocking reads
+  const flag = process.platform === 'darwin' ? '-f' : '-F';
+  try { execSync(`stty ${flag} ${ttyPath} raw -echo min 0 time 0`); } catch {}
+}
+
+function teardown() {
+  // Restore TTY to sane defaults
+  const flag = process.platform === 'darwin' ? '-f' : '-F';
+  try { execSync(`stty ${flag} ${ttyPath} sane`); } catch {}
+
+  // Erase game area and restore cursor visibility
+  let buf = SHOW_C;
+  for (let r = 0; r < GAME_H; r++) {
+    buf += pos(startRow + r, 1) + ' '.repeat(GAME_W);
+  }
+  writeTTY(buf);
+
+  try { fs.closeSync(ttyFd); } catch {}
+}
+
+// ── Entry point ───────────────────────────────────────────────────────────────
+function runGame(ttyPathArg, termRows) {
+  setup(ttyPathArg, termRows);
+
+  // Input polling (every 30ms for snappy response)
+  const inputInterval = setInterval(pollInput, 30);
+
+  // Game loop
+  const gameInterval = setInterval(() => {
+    update();
+    render();
+  }, TICK_MS);
+
+  render(); // initial frame
+
+  function exit() {
+    clearInterval(inputInterval);
+    clearInterval(gameInterval);
+    teardown();
+    process.exit(0);
+  }
+
+  process.on('SIGTERM', exit);
+  process.on('SIGINT',  exit);
+
+  // Auto-exit 2 seconds after game over (Claude is still working anyway)
+  const deathCheck = setInterval(() => {
+    if (dead) {
+      clearInterval(deathCheck);
+      render(); // show game over state
+      setTimeout(exit, 2000);
+    }
+  }, 200);
+}
+
+module.exports = { runGame };

package/src/animations.js

@@ -1,135 +0,0 @@
-'use strict';
-
-// ANSI colour codes
-const Y   = '\x1b[33m';   // yellow
-const C   = '\x1b[36m';   // cyan
-const G   = '\x1b[32m';   // green
-const R   = '\x1b[31m';   // red
-const W   = '\x1b[37m';   // white
-const DIM = '\x1b[2m';
-const RS  = '\x1b[0m';    // reset
-
-// ─────────────────────────────────────────────────────────────────────────
-// 1. COFFEE CUP  –  steam drifts above the cup
-//    Width: 13   Height: 7   Interval: 350 ms
-// ─────────────────────────────────────────────────────────────────────────
-const STEAM = [
-  '  ~   ~   ~  ',   // frame 0  (all 13 visible chars)
-  '   ~   ~   ~ ',   // frame 1
-  '~   ~   ~    ',   // frame 2
-  ' ~   ~   ~   ',   // frame 3
-];
-
-const CUP_BODY = [
-  `${Y}  .-------.  ${RS}`,
-  `${Y} |         | ${RS}`,
-  `${Y} |         |)${RS}`,
-  `${Y}  '-------'  ${RS}`,
-  `             `,
-  `             `,
-];
-
-const coffee = {
-  name: 'coffee',
-  width: 13,
-  intervalMs: 350,
-  frames: STEAM.map(s => [`${DIM}${s}${RS}`, ...CUP_BODY]),
-};
-
-// ─────────────────────────────────────────────────────────────────────────
-// 2. ROCKET  –  exhaust flame pulses beneath the rocket
-//    Width: 10   Height: 7   Interval: 180 ms
-// ─────────────────────────────────────────────────────────────────────────
-const EXHAUST = [
-  `   *  *   `,   // frame 0  (10 visible chars)
-  `  **  **  `,   // frame 1
-  ` **** *** `,   // frame 2
-  `  **  **  `,   // frame 3
-];
-
-const ROCKET_BODY = [
-  `${W}    /\\    ${RS}`,
-  `${W}   /  \\   ${RS}`,
-  `${W}  | ${C}**${W} |  ${RS}`,
-  `${W}  |    |  ${RS}`,
-  `${W}  '----'  ${RS}`,
-];
-
-const rocket = {
-  name: 'rocket',
-  width: 10,
-  intervalMs: 180,
-  frames: EXHAUST.map(e => [
-    ...ROCKET_BODY,
-    `${R}${e}${RS}`,
-    `          `,
-  ]),
-};
-
-// ─────────────────────────────────────────────────────────────────────────
-// 3. CLOCK  –  arrow hand rotates around the dial
-//    Width: 11   Height: 7   Interval: 130 ms
-// ─────────────────────────────────────────────────────────────────────────
-const CLOCK_ARROWS = ['↑', '↗', '→', '↘', '↓', '↙', '←', '↖'];
-
-const clock = {
-  name: 'clock',
-  width: 11,
-  intervalMs: 130,
-  frames: CLOCK_ARROWS.map(arrow => [
-    `${C}   .---.   ${RS}`,
-    `${C}  /     \\  ${RS}`,
-    `${C}  |  ${Y}${arrow}${C}  |  ${RS}`,
-    `${C}  |     |  ${RS}`,
-    `${C}  \\     /  ${RS}`,
-    `${C}   '---'   ${RS}`,
-    `           `,
-  ]),
-};
-
-// ─────────────────────────────────────────────────────────────────────────
-// 4. BOUNCING BALL  –  ball ricochets inside a box
-//    Width: 14   Height: 7   Interval: 110 ms
-// ─────────────────────────────────────────────────────────────────────────
-function makeBallFrames() {
-  const X_MAX = 11;   // x: 0 .. 11  (12 interior columns)
-  const Y_MAX = 2;    // y: 0 .. 2   (3 interior rows)
-  let x = 0, y = 0, vx = 1, vy = 1;
-  const frames = [];
-
-  const top = `${DIM}.------------.${RS}`;
-  const bot = `${DIM}'------------'${RS}`;
-  const pad = `              `;  // 14 spaces
-
-  for (let f = 0; f < 28; f++) {
-    const rows = [];
-    for (let row = 0; row <= Y_MAX; row++) {
-      const interior = row === y
-        ? ' '.repeat(x) + `${G}●${RS}` + ' '.repeat(X_MAX - x)
-        : ' '.repeat(X_MAX + 1);
-      rows.push(`${DIM}|${RS}${interior}${DIM}|${RS}`);
-    }
-    frames.push([top, ...rows, bot, pad, pad]);
-
-    // Move and bounce
-    x += vx; y += vy;
-    if (x <= 0)      { x = 0;      vx =  1; }
-    if (x >= X_MAX)  { x = X_MAX;  vx = -1; }
-    if (y <= 0)      { y = 0;      vy =  1; }
-    if (y >= Y_MAX)  { y = Y_MAX;  vy = -1; }
-  }
-
-  return frames;
-}
-
-const ball = {
-  name: 'ball',
-  width: 14,
-  intervalMs: 110,
-  frames: makeBallFrames(),
-};
-
-// ─────────────────────────────────────────────────────────────────────────
-// Export – add new animations to this object; daemon picks one at random.
-// ─────────────────────────────────────────────────────────────────────────
-module.exports = { coffee, rocket, clock, ball };