vibedino 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,1365 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  cli: () => cli
+});
+module.exports = __toCommonJS(cli_exports);
+
+// src/engine/GameLoop.ts
+var GameLoop = class {
+  constructor(onUpdate, onRender, fps = 30) {
+    this.onUpdate = onUpdate;
+    this.onRender = onRender;
+    this.tickMs = Math.floor(1e3 / fps);
+  }
+  onUpdate;
+  onRender;
+  intervalId = null;
+  running = false;
+  tickMs;
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.intervalId = setInterval(() => {
+      if (!this.running) return;
+      this.onUpdate(1);
+      this.onRender();
+    }, this.tickMs);
+  }
+  stop() {
+    this.running = false;
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+  isRunning() {
+    return this.running;
+  }
+};
+
+// src/engine/Renderer.ts
+var ESC = "\x1B";
+var CSI = `${ESC}[`;
+var Color = {
+  reset: `${CSI}0m`,
+  // Foreground
+  fg: (n) => `${CSI}38;5;${n}m`,
+  // Background
+  bg: (n) => `${CSI}48;5;${n}m`,
+  // RGB foreground
+  fgRgb: (r, g, b) => `${CSI}38;2;${r};${g};${b}m`,
+  // RGB background
+  bgRgb: (r, g, b) => `${CSI}48;2;${r};${g};${b}m`,
+  bold: `${CSI}1m`,
+  dim: `${CSI}2m`
+};
+var Renderer = class {
+  buffer = [];
+  width = 0;
+  height = 0;
+  defaultBg = "";
+  defaultFg = "";
+  constructor() {
+    this.width = process.stdout.columns || 80;
+    this.height = process.stdout.rows || 24;
+    this.clearBuffer();
+    process.stdout.write(`${CSI}?1049h${CSI}2J${CSI}?25l`);
+    process.stdout.on("resize", () => {
+      this.width = process.stdout.columns || 80;
+      this.height = process.stdout.rows || 24;
+      this.clearBuffer();
+    });
+  }
+  getWidth() {
+    return this.width;
+  }
+  getHeight() {
+    return this.height;
+  }
+  setDefaultColors(fg, bg) {
+    this.defaultFg = fg;
+    this.defaultBg = bg;
+  }
+  clearBuffer() {
+    this.buffer = [];
+    for (let y = 0; y < this.height; y++) {
+      this.buffer[y] = [];
+      for (let x = 0; x < this.width; x++) {
+        this.buffer[y][x] = { char: " ", fg: this.defaultFg, bg: this.defaultBg };
+      }
+    }
+  }
+  drawChar(x, y, ch, fg = "", bg = "") {
+    const rx = Math.round(x);
+    const ry = Math.round(y);
+    if (ry >= 0 && ry < this.height && rx >= 0 && rx < this.width) {
+      this.buffer[ry][rx] = { char: ch, fg: fg || this.defaultFg, bg: bg || this.defaultBg };
+    }
+  }
+  drawSprite(x, y, sprite, fg = "", bg = "") {
+    for (let row = 0; row < sprite.length; row++) {
+      const line = sprite[row];
+      for (let col = 0; col < line.length; col++) {
+        const ch = line[col];
+        if (ch !== " ") {
+          this.drawChar(x + col, y + row, ch, fg, bg);
+        }
+      }
+    }
+  }
+  drawText(x, y, text, fg = "", bg = "") {
+    for (let i = 0; i < text.length; i++) {
+      this.drawChar(x + i, y, text[i], fg, bg);
+    }
+  }
+  // Fill a rectangular area with a background color
+  fillRect(x, y, w, h, bg) {
+    for (let row = 0; row < h; row++) {
+      for (let col = 0; col < w; col++) {
+        const rx = Math.round(x + col);
+        const ry = Math.round(y + row);
+        if (ry >= 0 && ry < this.height && rx >= 0 && rx < this.width) {
+          this.buffer[ry][rx].bg = bg;
+        }
+      }
+    }
+  }
+  // Fill entire row with background color
+  fillRow(y, bg) {
+    if (y >= 0 && y < this.height) {
+      for (let x = 0; x < this.width; x++) {
+        this.buffer[y][x].bg = bg;
+      }
+    }
+  }
+  present() {
+    let out = "";
+    for (let y = 0; y < this.height; y++) {
+      out += `${CSI}${y + 1};1H`;
+      let lastFg = "";
+      let lastBg = "";
+      for (let x = 0; x < this.width; x++) {
+        const cell = this.buffer[y][x];
+        if (cell.fg !== lastFg || cell.bg !== lastBg) {
+          out += Color.reset;
+          if (cell.bg) out += cell.bg;
+          if (cell.fg) out += cell.fg;
+          lastFg = cell.fg;
+          lastBg = cell.bg;
+        }
+        out += cell.char;
+      }
+      out += Color.reset;
+    }
+    process.stdout.write(out);
+  }
+  destroy() {
+    process.stdout.write(`${Color.reset}${CSI}?25h${CSI}?1049l`);
+  }
+};
+
+// src/engine/Input.ts
+var Input = class {
+  actionQueue = [];
+  ducking = false;
+  rl = null;
+  bind() {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (key) => {
+      if (key === "") {
+        this.actionQueue.push(4 /* QUIT */);
+        return;
+      }
+      if (key === "\x1B[A" || key === " ") {
+        if (this.ducking) {
+          this.ducking = false;
+          this.actionQueue.push(2 /* DUCK_RELEASE */);
+        }
+        this.actionQueue.push(0 /* JUMP */);
+        return;
+      }
+      if (key === "\x1B[B") {
+        if (!this.ducking) {
+          this.ducking = true;
+          this.actionQueue.push(1 /* DUCK */);
+        }
+        return;
+      }
+      if (key === "\x1B" || key === "q" || key === "Q") {
+        this.actionQueue.push(4 /* QUIT */);
+        return;
+      }
+      if (key === "r" || key === "R") {
+        this.actionQueue.push(3 /* RESTART */);
+        return;
+      }
+      this.actionQueue.push(5 /* ANY_KEY */);
+    });
+  }
+  poll() {
+    const actions = [...this.actionQueue];
+    this.actionQueue = [];
+    return actions;
+  }
+  releaseDuck() {
+    this.ducking = false;
+  }
+  clear() {
+    this.actionQueue = [];
+  }
+  destroy() {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+  }
+};
+
+// src/scenes/SceneManager.ts
+var SceneManager = class {
+  current = null;
+  set(scene) {
+    this.current = scene;
+  }
+  update(dt) {
+    this.current?.update(dt);
+  }
+  render(renderer) {
+    this.current?.render(renderer);
+  }
+  handleInput(actions) {
+    this.current?.handleInput(actions);
+  }
+};
+
+// src/assets/sprites.ts
+var DINO_RUN_1 = [
+  "      \u2584\u2588\u2588\u2588\u2588\u2588",
+  "     \u2588\u2588\u2591\u2588 \u2588\u2588",
+  "  \u2584  \u2588\u2588\u2588\u2588\u2588\u2588 ",
+  "  \u2588\u2584\u2588\u2588\u2588\u2588\u2588\u2580  ",
+  "   \u2580\u2588\u2588\u2588\u2588\u2580   ",
+  "    \u2588\u2580\u2580\u2584    "
+];
+var DINO_RUN_2 = [
+  "      \u2584\u2588\u2588\u2588\u2588\u2588",
+  "     \u2588\u2588\u2591\u2588 \u2588\u2588",
+  "  \u2584  \u2588\u2588\u2588\u2588\u2588\u2588 ",
+  "  \u2588\u2584\u2588\u2588\u2588\u2588\u2588\u2580  ",
+  "   \u2580\u2588\u2588\u2588\u2588\u2580   ",
+  "    \u2584\u2580 \u2588\u2580   "
+];
+var DINO_JUMP = [
+  "      \u2584\u2588\u2588\u2588\u2588\u2588",
+  "     \u2588\u2588\u2591\u2588 \u2588\u2588",
+  "  \u2584  \u2588\u2588\u2588\u2588\u2588\u2588 ",
+  "  \u2588\u2584\u2588\u2588\u2588\u2588\u2588\u2580  ",
+  "   \u2580\u2588\u2588\u2588\u2588\u2580   ",
+  "    \u2588\u2580 \u2588\u2580   "
+];
+var DINO_DUCK_1 = [
+  "            ",
+  "            ",
+  "            ",
+  "  \u2584\u2588\u2588\u2588\u2588\u2588\u2588\u2584\u2588\u2588",
+  "  \u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588",
+  "   \u2580\u2580 \u2580\u2580   "
+];
+var DINO_DUCK_2 = [
+  "            ",
+  "            ",
+  "            ",
+  "  \u2584\u2588\u2588\u2588\u2588\u2588\u2588\u2584\u2588\u2588",
+  "  \u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588",
+  "    \u2580\u2580\u2580\u2580   "
+];
+var DINO_DEAD = [
+  "      \u2584\u2588\u2588\u2588\u2588\u2588",
+  "     \u2588\u2588X\u2588X\u2588\u2588",
+  "  \u2584  \u2588\u2588\u2588\u2588\u2588\u2588 ",
+  "  \u2588\u2584\u2588\u2588\u2588\u2588\u2588\u2580  ",
+  "   \u2580\u2588\u2588\u2588\u2588\u2580   ",
+  "    \u2588\u2580 \u2588\u2580   "
+];
+var CACTUS_SMALL = [
+  " \u2584\u2588\u2584 ",
+  "\u2580\u2588\u2588\u2588\u2580",
+  "  \u2588  ",
+  "  \u2588  "
+];
+var CACTUS_LARGE = [
+  "  \u2588  \u2584 ",
+  " \u2584\u2588\u2584\u2588\u2588 ",
+  "\u2580\u2588\u2588\u2588\u2588\u2580 ",
+  "  \u2588\u2580   ",
+  "  \u2588    "
+];
+var CACTUS_GROUP = [
+  " \u2584\u2588\u2584 \u2584\u2588\u2584 ",
+  "\u2580\u2588\u2588\u2588\u2580\u2588\u2588\u2588\u2588\u2580",
+  "  \u2588   \u2588   ",
+  "  \u2588   \u2588   "
+];
+var NODE_MODULES = [
+  "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
+  "\u2551node_mods/\u2551",
+  "\u2551 \u2593\u2593\u2593\u2593\u2593\u2593\u2593\u2593 \u2551",
+  "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+var NODE_MODULES_SMALL = [
+  "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
+  "\u2551n_mod/\u2551",
+  "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+var TODO_BIRD_1 = [
+  " \u2584\u2580\u2580\u2584//TODO",
+  "\u2580\u2584\u2584\u2580\u2580      "
+];
+var RATE_LIMIT = [
+  "\u2554\u2550\u2550\u2550\u2550\u2550\u2557",
+  "\u2551 429 \u2551",
+  "\u2551LIMIT\u2551",
+  "\u255A\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+var MERGE_CONFLICT = [
+  "\u25C4\u25C4\u25C4HEAD",
+  "\u2550\u2550\u2550\u2550\u2550\u2550\u2550",
+  "\u25BA\u25BA\u25BAmain"
+];
+var GROUND_CHARS = "\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581\u2581";
+var CLOUD_1 = [
+  "  \u2584\u2584\u2584\u2584   ",
+  "\u2580\u2580\u2580\u2580\u2580\u2580\u2580\u2580 "
+];
+var CLOUD_2 = [
+  " \u2584\u2584\u2584  ",
+  "\u2580\u2580\u2580\u2580\u2580 "
+];
+var STAR_CHARS = ["\xB7", "\u2219", "\u2022", "\xB0"];
+var GAME_OVER_TEXT = [
+  "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557",
+  "\u2551    G A M E   O V E R    \u2551",
+  "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
+];
+var TITLE_DINO = [
+  "            \u2584\u2584\u2588\u2588\u2588\u2588\u2584\u2584       ",
+  "          \u2584\u2588\u2588\u2591\u2591\u2588\u2588\u2584\u2588\u2588\u2588\u2588     ",
+  "          \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588     ",
+  "  \u2584\u2584    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2580\u2580         ",
+  "  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2580           ",
+  "   \u2580\u2580\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2580\u2580            ",
+  "      \u2588\u2588\u2580\u2580\u2588\u2588               ",
+  "      \u2588    \u2588               "
+];
+
+// src/ui/Messages.ts
+var TITLE_MESSAGES = {
+  claude: [
+    "Claude ran out of tokens!",
+    "Token limit reached. Time to play!",
+    "Rate limited by Claude. Quick, run!"
+  ],
+  copilot: [
+    "Copilot hit its limit!",
+    "Copilot needs a break. You play!",
+    "Rate limited. Copilot is resting."
+  ],
+  default: [
+    "No tokens? No problem!",
+    "Token drought detected!",
+    "AI is resting. Dino is not."
+  ]
+};
+var GAME_OVER_QUIPS = [
+  "Tokens still regenerating...",
+  "Your AI will be back soon.",
+  "That was fun! Press R to retry.",
+  "node_modules got you!",
+  "Even dinos get merge conflicts.",
+  "HTTP 429: Too Many Jumps"
+];
+function getTitleMessage(source) {
+  const pool = TITLE_MESSAGES[source ?? "default"] ?? TITLE_MESSAGES.default;
+  return pool[Math.floor(Math.random() * pool.length)];
+}
+function getGameOverQuip() {
+  return GAME_OVER_QUIPS[Math.floor(Math.random() * GAME_OVER_QUIPS.length)];
+}
+
+// src/assets/theme.ts
+var SKY = {
+  top: Color.bgRgb(25, 25, 50),
+  // dark blue-black
+  mid: Color.bgRgb(35, 35, 65),
+  // slightly lighter
+  bottom: Color.bgRgb(50, 45, 75)
+  // dusk purple
+};
+var GROUND_BG = Color.bgRgb(60, 50, 30);
+var GROUND_DEEP = Color.bgRgb(45, 38, 22);
+var DINO_FG = Color.fgRgb(80, 200, 80);
+var DINO_EYE = Color.fgRgb(255, 255, 255);
+var CACTUS_FG = Color.fgRgb(50, 160, 50);
+var OBSTACLE_FG = Color.fgRgb(200, 160, 60);
+var BIRD_FG = Color.fgRgb(180, 100, 200);
+var CLOUD_FG = Color.fgRgb(120, 120, 160);
+var GROUND_FG = Color.fgRgb(140, 110, 60);
+var SCORE_FG = Color.fgRgb(255, 255, 200);
+var TITLE_FG = Color.fgRgb(100, 220, 100);
+var GAMEOVER_FG = Color.fgRgb(255, 80, 80);
+var PROMPT_FG = Color.fgRgb(255, 255, 100);
+var HI_SCORE_FG = Color.fgRgb(255, 200, 50);
+var QUIP_FG = Color.fgRgb(150, 150, 170);
+function getObstacleColor(type) {
+  switch (type) {
+    case "cactus_small":
+    case "cactus_large":
+    case "cactus_group":
+      return CACTUS_FG;
+    case "todo_bird":
+      return BIRD_FG;
+    case "node_modules":
+    case "node_modules_small":
+    case "rate_limit":
+    case "merge_conflict":
+      return OBSTACLE_FG;
+    default:
+      return "";
+  }
+}
+function getSkyBg(y, height) {
+  const t = y / height;
+  const r = Math.round(25 + t * 35);
+  const g = Math.round(25 + t * 25);
+  const b = Math.round(50 + t * 30);
+  return Color.bgRgb(r, g, b);
+}
+
+// src/scenes/TitleScene.ts
+var TitleScene = class {
+  message;
+  progressTick = 0;
+  progressTotal = 75;
+  ready = false;
+  onStart;
+  blinkTick = 0;
+  constructor(source, onStart) {
+    this.message = getTitleMessage(source);
+    this.onStart = onStart;
+  }
+  update(_dt) {
+    this.blinkTick++;
+    if (!this.ready) {
+      this.progressTick++;
+      if (this.progressTick >= this.progressTotal) {
+        this.ready = true;
+      }
+    }
+  }
+  render(renderer) {
+    renderer.clearBuffer();
+    const w = renderer.getWidth();
+    const h = renderer.getHeight();
+    for (let y = 0; y < h; y++) {
+      renderer.fillRow(y, getSkyBg(y, h));
+    }
+    const titleY = Math.floor(h * 0.12);
+    const titleStr = "V I B E   D I N O";
+    renderer.drawText(Math.floor(w / 2) - Math.floor(titleStr.length / 2), titleY, titleStr, TITLE_FG);
+    const sub = "Token Exhaustion Entertainment";
+    renderer.drawText(Math.floor(w / 2) - Math.floor(sub.length / 2), titleY + 2, sub, QUIP_FG);
+    const dinoY = titleY + 5;
+    const dinoX = Math.floor(w / 2) - Math.floor(TITLE_DINO[0].length / 2);
+    renderer.drawSprite(dinoX, dinoY, TITLE_DINO, DINO_FG);
+    const groundY = dinoY + TITLE_DINO.length;
+    renderer.fillRow(groundY, GROUND_BG);
+    renderer.drawText(0, groundY, GROUND_CHARS.slice(0, w), GROUND_FG, GROUND_BG);
+    const msgY = groundY + 2;
+    renderer.drawText(Math.floor(w / 2) - Math.floor(this.message.length / 2), msgY, this.message, SCORE_FG);
+    const barY = msgY + 2;
+    if (!this.ready) {
+      const barWidth = 32;
+      const filled = Math.floor(this.progressTick / this.progressTotal * barWidth);
+      const barFull = "\u2588".repeat(filled);
+      const barEmpty = "\u2591".repeat(barWidth - filled);
+      const pct = Math.floor(this.progressTick / this.progressTotal * 100);
+      renderer.drawText(Math.floor(w / 2) - Math.floor(barWidth / 2) - 1, barY, "\u2551", QUIP_FG);
+      renderer.drawText(Math.floor(w / 2) - Math.floor(barWidth / 2), barY, barFull, Color.fgRgb(80, 220, 80));
+      renderer.drawText(Math.floor(w / 2) - Math.floor(barWidth / 2) + filled, barY, barEmpty, QUIP_FG);
+      renderer.drawText(Math.floor(w / 2) + Math.floor(barWidth / 2), barY, "\u2551", QUIP_FG);
+      const label = `Regenerating tokens... ${pct}%`;
+      renderer.drawText(Math.floor(w / 2) - Math.floor(label.length / 2), barY + 1, label, QUIP_FG);
+    } else {
+      if (Math.floor(this.blinkTick / 18) % 2 === 0) {
+        const prompt = ">>>  Press SPACE to start  <<<";
+        renderer.drawText(Math.floor(w / 2) - Math.floor(prompt.length / 2), barY, prompt, PROMPT_FG);
+      }
+    }
+    const footer = "SPACE/UP: Jump  |  DOWN: Duck  |  Q: Quit";
+    renderer.drawText(Math.floor(w / 2) - Math.floor(footer.length / 2), h - 2, footer, QUIP_FG);
+    renderer.present();
+  }
+  handleInput(actions) {
+    if (!this.ready) return;
+    for (const action of actions) {
+      if (action === 4 /* QUIT */) {
+        process.exit(0);
+      }
+      if (action === 0 /* JUMP */ || action === 5 /* ANY_KEY */) {
+        this.onStart();
+        return;
+      }
+    }
+  }
+};
+
+// src/entities/Entity.ts
+var Entity = class {
+  x;
+  y;
+  vx = 0;
+  vy = 0;
+  grounded = false;
+  active = true;
+  sprite = [];
+  hitboxDef = { offsetX: 0, offsetY: 0, width: 0, height: 0 };
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  getHitbox() {
+    return {
+      x: this.x + this.hitboxDef.offsetX,
+      y: this.y + this.hitboxDef.offsetY,
+      width: this.hitboxDef.width,
+      height: this.hitboxDef.height
+    };
+  }
+  update(_dt) {
+  }
+};
+
+// src/entities/Dino.ts
+var Dino = class extends Entity {
+  state = 0 /* IDLE */;
+  animFrame = 0;
+  animTick = 0;
+  animSpeed = 4;
+  // ticks per frame swap
+  constructor(x, groundY) {
+    super(x, groundY);
+    this.grounded = true;
+    this.updateSprite();
+    this.updateHitbox();
+  }
+  setState(state) {
+    if (this.state === state) return;
+    this.state = state;
+    this.animFrame = 0;
+    this.animTick = 0;
+    this.updateSprite();
+    this.updateHitbox();
+  }
+  update(_dt) {
+    this.animTick++;
+    if (this.animTick >= this.animSpeed) {
+      this.animTick = 0;
+      this.animFrame = (this.animFrame + 1) % 2;
+      this.updateSprite();
+    }
+    if (this.state === 2 /* JUMPING */ && this.grounded) {
+      this.setState(1 /* RUNNING */);
+    }
+  }
+  updateSprite() {
+    switch (this.state) {
+      case 0 /* IDLE */:
+      case 1 /* RUNNING */:
+        this.sprite = this.animFrame === 0 ? DINO_RUN_1 : DINO_RUN_2;
+        break;
+      case 2 /* JUMPING */:
+        this.sprite = DINO_JUMP;
+        break;
+      case 3 /* DUCKING */:
+        this.sprite = this.animFrame === 0 ? DINO_DUCK_1 : DINO_DUCK_2;
+        break;
+      case 4 /* DEAD */:
+        this.sprite = DINO_DEAD;
+        break;
+    }
+  }
+  updateHitbox() {
+    if (this.state === 3 /* DUCKING */) {
+      this.hitboxDef = { offsetX: 2, offsetY: 3, width: 9, height: 3 };
+    } else {
+      this.hitboxDef = { offsetX: 3, offsetY: 0, width: 8, height: 5 };
+    }
+  }
+};
+
+// src/entities/Ground.ts
+var Ground = class {
+  offset = 0;
+  pattern;
+  constructor() {
+    this.pattern = GROUND_CHARS + GROUND_CHARS;
+  }
+  update(speed) {
+    this.offset = (this.offset + speed) % GROUND_CHARS.length;
+  }
+  getOffset() {
+    return this.offset;
+  }
+  getLine(width) {
+    const start = Math.floor(this.offset);
+    return this.pattern.slice(start, start + width);
+  }
+};
+
+// src/entities/Cloud.ts
+var Cloud = class extends Entity {
+  constructor(x, y) {
+    super(x, y);
+    this.sprite = Math.random() > 0.5 ? CLOUD_1 : CLOUD_2;
+    this.vx = -(0.2 + Math.random() * 0.3);
+  }
+  update(_dt) {
+    this.x += this.vx;
+  }
+};
+
+// src/entities/obstacles/Obstacle.ts
+var Obstacle = class extends Entity {
+  type;
+  isFlying;
+  constructor(x, y, type, sprite, isFlying = false) {
+    super(x, y);
+    this.type = type;
+    this.sprite = sprite;
+    this.isFlying = isFlying;
+    this.grounded = !isFlying;
+    const spriteWidth = Math.max(...sprite.map((l) => l.length));
+    const spriteHeight = sprite.length;
+    this.hitboxDef = {
+      offsetX: 1,
+      offsetY: 1,
+      width: Math.max(1, spriteWidth - 2),
+      height: Math.max(1, spriteHeight - 1)
+    };
+  }
+  update(_dt) {
+    this.x += this.vx;
+  }
+};
+
+// src/systems/SpawnSystem.ts
+var OBSTACLE_DEFS = [
+  { type: "cactus_small", sprite: CACTUS_SMALL, isFlying: false, minDifficulty: 0 },
+  { type: "cactus_large", sprite: CACTUS_LARGE, isFlying: false, minDifficulty: 0.05 },
+  { type: "cactus_group", sprite: CACTUS_GROUP, isFlying: false, minDifficulty: 0.1 },
+  { type: "node_modules_small", sprite: NODE_MODULES_SMALL, isFlying: false, minDifficulty: 0.15 },
+  { type: "node_modules", sprite: NODE_MODULES, isFlying: false, minDifficulty: 0.25 },
+  { type: "merge_conflict", sprite: MERGE_CONFLICT, isFlying: false, minDifficulty: 0.3 },
+  { type: "rate_limit", sprite: RATE_LIMIT, isFlying: false, minDifficulty: 0.35 },
+  { type: "todo_bird", sprite: TODO_BIRD_1, isFlying: true, minDifficulty: 0.4 }
+];
+var SpawnSystem = class {
+  ticksSinceSpawn = 0;
+  minGapTicks = 45;
+  maxGapTicks = 90;
+  nextSpawnAt;
+  constructor() {
+    this.nextSpawnAt = this.randomGap();
+  }
+  update(obstacles, screenWidth, groundY, speed, difficulty) {
+    this.ticksSinceSpawn++;
+    this.minGapTicks = Math.max(25, 45 - difficulty * 20);
+    this.maxGapTicks = Math.max(50, 90 - difficulty * 30);
+    if (this.ticksSinceSpawn >= this.nextSpawnAt) {
+      const available = OBSTACLE_DEFS.filter((d) => d.minDifficulty <= difficulty);
+      const def = available[Math.floor(Math.random() * available.length)];
+      const spriteH = def.sprite.length;
+      const yPos = def.isFlying ? groundY - spriteH - 3 - Math.floor(Math.random() * 3) : groundY - spriteH;
+      const obs = new Obstacle(screenWidth + 2, yPos, def.type, def.sprite, def.isFlying);
+      obs.vx = speed;
+      obstacles.push(obs);
+      this.ticksSinceSpawn = 0;
+      this.nextSpawnAt = this.randomGap();
+    }
+  }
+  randomGap() {
+    return this.minGapTicks + Math.floor(Math.random() * (this.maxGapTicks - this.minGapTicks));
+  }
+  reset() {
+    this.ticksSinceSpawn = 0;
+    this.nextSpawnAt = this.randomGap();
+  }
+};
+
+// src/systems/DifficultySystem.ts
+var DifficultySystem = class {
+  ticks = 0;
+  maxSpeedMultiplier = 2.5;
+  rampDurationTicks = 30 * 120;
+  // ~120 seconds at 30fps to reach max
+  /** Current difficulty 0..1 */
+  difficulty = 0;
+  /** Current game scroll speed (negative = moving left) */
+  speed = -1.2;
+  baseSpeed = -1.2;
+  update() {
+    this.ticks++;
+    this.difficulty = Math.min(1, this.ticks / this.rampDurationTicks);
+    this.speed = this.baseSpeed * (1 + this.difficulty * (this.maxSpeedMultiplier - 1));
+  }
+  reset() {
+    this.ticks = 0;
+    this.difficulty = 0;
+    this.speed = this.baseSpeed;
+  }
+};
+
+// src/systems/ScoreSystem.ts
+var ScoreSystem = class {
+  score = 0;
+  tickAccumulator = 0;
+  pointsPerSecond = 10;
+  ticksPerPoint;
+  milestone = false;
+  // true on the tick a milestone is hit
+  constructor(fps = 30) {
+    this.ticksPerPoint = Math.floor(fps / this.pointsPerSecond);
+  }
+  update() {
+    this.milestone = false;
+    this.tickAccumulator++;
+    if (this.tickAccumulator >= this.ticksPerPoint) {
+      this.tickAccumulator = 0;
+      this.score++;
+      if (this.score > 0 && this.score % 100 === 0) {
+        this.milestone = true;
+      }
+    }
+  }
+  getDisplay() {
+    return String(this.score).padStart(5, "0");
+  }
+  reset() {
+    this.score = 0;
+    this.tickAccumulator = 0;
+    this.milestone = false;
+  }
+};
+
+// src/ui/HUD.ts
+var HUD = class {
+  render(renderer, score, highScore) {
+    const w = renderer.getWidth();
+    renderer.drawText(w - 7, 1, score, SCORE_FG);
+    renderer.drawText(w - 16, 1, "HI", HI_SCORE_FG);
+    renderer.drawText(w - 13, 1, highScore, HI_SCORE_FG);
+  }
+};
+
+// src/engine/Physics.ts
+var GRAVITY = 0.35;
+var JUMP_VELOCITY = -3.5;
+var MAX_FALL_SPEED = 5;
+function applyGravity(entity, groundY) {
+  if (entity.grounded) return;
+  entity.vy += GRAVITY;
+  if (entity.vy > MAX_FALL_SPEED) {
+    entity.vy = MAX_FALL_SPEED;
+  }
+  entity.y += entity.vy;
+  if (entity.y >= groundY) {
+    entity.y = groundY;
+    entity.vy = 0;
+    entity.grounded = true;
+  }
+}
+function jump(entity) {
+  if (!entity.grounded) return;
+  entity.vy = JUMP_VELOCITY;
+  entity.grounded = false;
+}
+
+// src/engine/Collision.ts
+function checkCollision(a, b) {
+  return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y;
+}
+
+// src/scenes/PlayScene.ts
+var PlayScene = class {
+  dino;
+  ground;
+  obstacles = [];
+  clouds = [];
+  spawnSystem = new SpawnSystem();
+  difficulty = new DifficultySystem();
+  scoreSystem = new ScoreSystem();
+  hud = new HUD();
+  groundY;
+  screenWidth;
+  screenHeight;
+  dead = false;
+  highScoreDisplay;
+  onGameOver;
+  cloudSpawnTick = 0;
+  stars = [];
+  constructor(screenWidth, screenHeight, highScore, onGameOver) {
+    this.screenWidth = screenWidth;
+    this.screenHeight = screenHeight;
+    this.groundY = screenHeight - 3;
+    this.dino = new Dino(6, this.groundY - 6);
+    this.dino.setState(1 /* RUNNING */);
+    this.ground = new Ground();
+    this.highScoreDisplay = String(highScore).padStart(5, "0");
+    this.onGameOver = onGameOver;
+    for (let i = 0; i < 25; i++) {
+      this.stars.push({
+        x: Math.floor(Math.random() * screenWidth),
+        y: Math.floor(Math.random() * (this.groundY - 2)),
+        char: STAR_CHARS[Math.floor(Math.random() * STAR_CHARS.length)],
+        bright: 40 + Math.floor(Math.random() * 80)
+      });
+    }
+  }
+  update(dt) {
+    if (this.dead) return;
+    this.difficulty.update();
+    this.scoreSystem.update();
+    applyGravity(this.dino, this.groundY - 6);
+    this.dino.update(dt);
+    this.ground.update(Math.abs(this.difficulty.speed));
+    this.spawnSystem.update(
+      this.obstacles,
+      this.screenWidth,
+      this.groundY,
+      this.difficulty.speed,
+      this.difficulty.difficulty
+    );
+    for (const obs of this.obstacles) {
+      obs.vx = this.difficulty.speed;
+      obs.update(dt);
+    }
+    this.obstacles = this.obstacles.filter((o) => o.x + 20 > 0);
+    this.cloudSpawnTick++;
+    if (this.cloudSpawnTick > 60 + Math.random() * 120) {
+      this.cloudSpawnTick = 0;
+      if (this.clouds.length < 5) {
+        this.clouds.push(new Cloud(this.screenWidth + 5, 1 + Math.floor(Math.random() * 5)));
+      }
+    }
+    for (const cloud of this.clouds) cloud.update(dt);
+    this.clouds = this.clouds.filter((c) => c.x + 12 > 0);
+    const dinoBox = this.dino.getHitbox();
+    for (const obs of this.obstacles) {
+      if (checkCollision(dinoBox, obs.getHitbox())) {
+        this.dead = true;
+        this.dino.setState(4 /* DEAD */);
+        this.onGameOver(this.scoreSystem.score);
+        return;
+      }
+    }
+  }
+  render(renderer) {
+    renderer.clearBuffer();
+    for (let y = 0; y < this.groundY; y++) {
+      renderer.fillRow(y, getSkyBg(y, this.groundY));
+    }
+    for (const star of this.stars) {
+      renderer.drawChar(
+        star.x,
+        star.y,
+        star.char,
+        Color.fgRgb(star.bright, star.bright, star.bright + 30)
+      );
+    }
+    for (let y = this.groundY; y < this.screenHeight; y++) {
+      renderer.fillRow(y, y === this.groundY ? GROUND_BG : GROUND_DEEP);
+    }
+    for (let y = this.groundY + 1; y < this.screenHeight; y++) {
+      const offset = Math.floor(this.ground.getOffset() * 0.5) % this.screenWidth;
+      for (let x = 0; x < this.screenWidth; x++) {
+        if ((x + offset + y * 7) % 13 === 0) {
+          renderer.drawChar(x, y, "\xB7", Color.fgRgb(80, 65, 40), GROUND_DEEP);
+        }
+        if ((x + offset + y * 11) % 19 === 0) {
+          renderer.drawChar(x, y, "\u2219", Color.fgRgb(70, 55, 35), GROUND_DEEP);
+        }
+      }
+    }
+    for (const cloud of this.clouds) {
+      renderer.drawSprite(Math.round(cloud.x), Math.round(cloud.y), cloud.sprite, CLOUD_FG);
+    }
+    const groundLine = this.ground.getLine(this.screenWidth);
+    renderer.drawText(0, this.groundY, groundLine, GROUND_FG, GROUND_BG);
+    for (const obs of this.obstacles) {
+      const color = getObstacleColor(obs.type);
+      renderer.drawSprite(Math.round(obs.x), Math.round(obs.y), obs.sprite, color);
+    }
+    const dinoColor = this.dead ? GAMEOVER_FG : DINO_FG;
+    renderer.drawSprite(
+      Math.round(this.dino.x),
+      Math.round(this.dino.y),
+      this.dino.sprite,
+      dinoColor
+    );
+    this.hud.render(renderer, this.scoreSystem.getDisplay(), this.highScoreDisplay);
+    if (this.scoreSystem.milestone) {
+      const msg = `+${this.scoreSystem.score}!`;
+      renderer.drawText(
+        Math.floor(this.screenWidth / 2) - Math.floor(msg.length / 2),
+        2,
+        msg,
+        GAMEOVER_FG
+      );
+    }
+    renderer.present();
+  }
+  handleInput(actions) {
+    if (this.dead) return;
+    for (const action of actions) {
+      switch (action) {
+        case 0 /* JUMP */:
+          if (this.dino.state === 3 /* DUCKING */) {
+            this.dino.setState(1 /* RUNNING */);
+          }
+          jump(this.dino);
+          if (!this.dino.grounded) {
+            this.dino.setState(2 /* JUMPING */);
+          }
+          break;
+        case 1 /* DUCK */:
+          if (this.dino.grounded) {
+            this.dino.setState(3 /* DUCKING */);
+          }
+          break;
+        case 2 /* DUCK_RELEASE */:
+          if (this.dino.state === 3 /* DUCKING */) {
+            this.dino.setState(1 /* RUNNING */);
+          }
+          break;
+        case 4 /* QUIT */:
+          this.dead = true;
+          this.onGameOver(this.scoreSystem.score);
+          break;
+      }
+    }
+  }
+};
+
+// src/scenes/GameOverScene.ts
+var GameOverScene = class {
+  score;
+  highScore;
+  isNewHighScore;
+  quip;
+  onRestart;
+  onQuit;
+  blinkTick = 0;
+  constructor(score, highScore, isNewHighScore, onRestart, onQuit) {
+    this.score = score;
+    this.highScore = highScore;
+    this.isNewHighScore = isNewHighScore;
+    this.quip = getGameOverQuip();
+    this.onRestart = onRestart;
+    this.onQuit = onQuit;
+  }
+  update(_dt) {
+    this.blinkTick++;
+  }
+  render(renderer) {
+    renderer.clearBuffer();
+    const w = renderer.getWidth();
+    const h = renderer.getHeight();
+    for (let y = 0; y < h; y++) {
+      renderer.fillRow(y, Color.bgRgb(20, 15, 30));
+    }
+    const centerY = Math.floor(h / 2) - 6;
+    const bannerX = Math.floor(w / 2) - Math.floor(GAME_OVER_TEXT[0].length / 2);
+    renderer.drawSprite(bannerX, centerY, GAME_OVER_TEXT, GAMEOVER_FG);
+    const dinoX = Math.floor(w / 2) - Math.floor(DINO_DEAD[0].length / 2);
+    renderer.drawSprite(dinoX, centerY + 4, DINO_DEAD, Color.fgRgb(100, 100, 100));
+    const scoreY = centerY + 4 + DINO_DEAD.length + 1;
+    const scoreText = `Score  ${String(this.score).padStart(5, "0")}`;
+    renderer.drawText(Math.floor(w / 2) - Math.floor(scoreText.length / 2), scoreY, scoreText, SCORE_FG);
+    const hiY = scoreY + 2;
+    if (this.isNewHighScore) {
+      const hiText = "* * *  NEW HIGH SCORE!  * * *";
+      if (Math.floor(this.blinkTick / 8) % 2 === 0) {
+        renderer.drawText(Math.floor(w / 2) - Math.floor(hiText.length / 2), hiY, hiText, HI_SCORE_FG);
+      }
+    } else {
+      const hiText = `Best   ${String(this.highScore).padStart(5, "0")}`;
+      renderer.drawText(Math.floor(w / 2) - Math.floor(hiText.length / 2), hiY, hiText, HI_SCORE_FG);
+    }
+    renderer.drawText(Math.floor(w / 2) - Math.floor(this.quip.length / 2), hiY + 2, this.quip, QUIP_FG);
+    if (Math.floor(this.blinkTick / 18) % 2 === 0) {
+      const prompt = "[R] Restart     [Q] Quit";
+      renderer.drawText(Math.floor(w / 2) - Math.floor(prompt.length / 2), hiY + 4, prompt, PROMPT_FG);
+    }
+    renderer.present();
+  }
+  handleInput(actions) {
+    for (const action of actions) {
+      if (action === 3 /* RESTART */) {
+        this.onRestart();
+        return;
+      }
+      if (action === 4 /* QUIT */) {
+        this.onQuit();
+        return;
+      }
+    }
+  }
+};
+
+// src/storage/ScoreStore.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+var STORE_DIR = (0, import_path.join)((0, import_os.homedir)(), ".vibedino");
+var SCORES_FILE = (0, import_path.join)(STORE_DIR, "scores.json");
+function ensureDir() {
+  if (!(0, import_fs.existsSync)(STORE_DIR)) {
+    (0, import_fs.mkdirSync)(STORE_DIR, { recursive: true });
+  }
+}
+function load() {
+  try {
+    const raw = (0, import_fs.readFileSync)(SCORES_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return { highScore: 0, scores: [] };
+  }
+}
+function save(data) {
+  ensureDir();
+  (0, import_fs.writeFileSync)(SCORES_FILE, JSON.stringify(data, null, 2), "utf-8");
+}
+function getHighScore() {
+  return load().highScore;
+}
+function saveScore(score) {
+  const data = load();
+  const isNew = score > data.highScore;
+  if (isNew) {
+    data.highScore = score;
+  }
+  data.scores.push({ score, date: (/* @__PURE__ */ new Date()).toISOString() });
+  data.scores.sort((a, b) => b.score - a.score);
+  data.scores = data.scores.slice(0, 10);
+  save(data);
+  return { highScore: data.highScore, isNew };
+}
+function getTopScores() {
+  return load().scores;
+}
+function resetScores() {
+  save({ highScore: 0, scores: [] });
+}
+
+// src/index.ts
+function startGame(options = {}) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const trigger = {
+      source: options.source ?? "cli",
+      reason: options.reason,
+      metadata: options.metadata
+    };
+    const renderer = new Renderer();
+    const input = new Input();
+    const sceneManager = new SceneManager();
+    input.bind();
+    let finalResult = null;
+    const cleanup = () => {
+      loop.stop();
+      input.destroy();
+      renderer.destroy();
+      if (finalResult) resolve(finalResult);
+    };
+    const startPlay = () => {
+      const highScore = getHighScore();
+      const scene = new PlayScene(
+        renderer.getWidth(),
+        renderer.getHeight(),
+        highScore,
+        (score) => {
+          const { highScore: newHigh, isNew } = saveScore(score);
+          finalResult = {
+            score,
+            highScore: newHigh,
+            isNewHighScore: isNew,
+            duration: Date.now() - startTime,
+            trigger
+          };
+          sceneManager.set(new GameOverScene(
+            score,
+            newHigh,
+            isNew,
+            () => {
+              input.clear();
+              startPlay();
+            },
+            () => {
+              cleanup();
+            }
+          ));
+        }
+      );
+      sceneManager.set(scene);
+    };
+    const titleScene = new TitleScene(trigger.source, () => {
+      input.clear();
+      startPlay();
+    });
+    sceneManager.set(titleScene);
+    const loop = new GameLoop(
+      (dt) => {
+        const actions = input.poll();
+        sceneManager.handleInput(actions);
+        sceneManager.update(dt);
+      },
+      () => {
+        sceneManager.render(renderer);
+      }
+    );
+    loop.start();
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  });
+}
+
+// src/integrations/claudeCode.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var HOOK_ENTRY = {
+  matcher: "rate_limit|token_limit|quota_exceeded|overloaded",
+  command: 'npx vibedino --trigger claude --reason "Token limit reached"',
+  timeout: 3e5
+};
+function installClaudeHook(projectDir = process.cwd()) {
+  const claudeDir = (0, import_path2.join)(projectDir, ".claude");
+  const settingsPath = (0, import_path2.join)(claudeDir, "settings.json");
+  if (!(0, import_fs2.existsSync)(claudeDir)) {
+    (0, import_fs2.mkdirSync)(claudeDir, { recursive: true });
+  }
+  let settings = {};
+  if ((0, import_fs2.existsSync)(settingsPath)) {
+    try {
+      settings = JSON.parse((0, import_fs2.readFileSync)(settingsPath, "utf-8"));
+    } catch {
+    }
+  }
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+  const hooks = settings.hooks;
+  if (!hooks.PostToolUseFailure) {
+    hooks.PostToolUseFailure = [];
+  }
+  const existing = hooks.PostToolUseFailure;
+  if (!existing.some((h) => h.command?.includes("vibedino"))) {
+    existing.push(HOOK_ENTRY);
+  }
+  (0, import_fs2.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  console.log(`  Installed VibeDino hook in ${settingsPath}`);
+}
+function uninstallClaudeHook(projectDir = process.cwd()) {
+  const settingsPath = (0, import_path2.join)(projectDir, ".claude", "settings.json");
+  if (!(0, import_fs2.existsSync)(settingsPath)) {
+    console.log("  No .claude/settings.json found.");
+    return;
+  }
+  const settings = JSON.parse((0, import_fs2.readFileSync)(settingsPath, "utf-8"));
+  const hooks = settings.hooks?.PostToolUseFailure;
+  if (hooks) {
+    settings.hooks.PostToolUseFailure = hooks.filter(
+      (h) => !h.command?.includes("vibedino")
+    );
+  }
+  (0, import_fs2.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  console.log(`  Removed VibeDino hook from ${settingsPath}`);
+}
+
+// src/integrations/copilotCli.ts
+var import_fs3 = require("fs");
+var import_path3 = require("path");
+var import_os2 = require("os");
+var PLUGIN_DIR = (0, import_path3.join)((0, import_os2.homedir)(), ".copilot", "plugins", "vibedino");
+var MANIFEST_PATH = (0, import_path3.join)(PLUGIN_DIR, "plugin.json");
+function generateCopilotPluginManifest() {
+  return {
+    name: "vibedino",
+    version: "0.1.0",
+    description: "Play dino runner when rate limited",
+    hooks: {
+      onError: {
+        match: ["rate_limit", "token_exhausted", "429"],
+        action: "exec",
+        command: 'npx vibedino --trigger copilot --reason "Rate limited"'
+      }
+    }
+  };
+}
+function installCopilotPlugin() {
+  if (!(0, import_fs3.existsSync)(PLUGIN_DIR)) {
+    (0, import_fs3.mkdirSync)(PLUGIN_DIR, { recursive: true });
+  }
+  const manifest = generateCopilotPluginManifest();
+  (0, import_fs3.writeFileSync)(MANIFEST_PATH, JSON.stringify(manifest, null, 2), "utf-8");
+  console.log(`  Installed VibeDino Copilot plugin at ${MANIFEST_PATH}`);
+}
+function uninstallCopilotPlugin() {
+  if (!(0, import_fs3.existsSync)(MANIFEST_PATH)) {
+    console.log("  No VibeDino Copilot plugin found.");
+    return;
+  }
+  (0, import_fs3.unlinkSync)(MANIFEST_PATH);
+  try {
+    (0, import_fs3.rmdirSync)(PLUGIN_DIR);
+  } catch {
+  }
+  console.log("  Removed VibeDino Copilot plugin.");
+}
+
+// src/cli.ts
+function printHelp() {
+  console.log(`
+  vibedino - Terminal T-Rex runner for when AI tools run out of tokens
+
+  USAGE
+    vibedino [options]
+
+  OPTIONS
+    --trigger <source>   Trigger source: claude, copilot, cli (default: cli)
+    --reason <text>      Why the game was triggered
+    --install <target>   Install integration: claude, copilot
+    --uninstall <target> Remove integration: claude, copilot
+    --scores             Show high scores and exit
+    --reset              Reset high scores
+    --help, -h           Show this help
+    --version, -v        Show version
+
+  CONTROLS
+    SPACE / UP     Jump
+    DOWN           Duck
+    R              Restart (on game over)
+    Q / ESC        Quit
+  `);
+}
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      args.help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      args.version = true;
+    } else if (arg === "--scores") {
+      args.scores = true;
+    } else if (arg === "--reset") {
+      args.reset = true;
+    } else if (arg === "--trigger" && argv[i + 1]) {
+      args.trigger = argv[++i];
+    } else if (arg === "--reason" && argv[i + 1]) {
+      args.reason = argv[++i];
+    } else if (arg === "--install" && argv[i + 1]) {
+      args.install = argv[++i];
+    } else if (arg === "--uninstall" && argv[i + 1]) {
+      args.uninstall = argv[++i];
+    }
+  }
+  return args;
+}
+async function cli(argv) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    printHelp();
+    process.exit(0);
+  }
+  if (args.version) {
+    console.log("vibedino v0.1.0");
+    process.exit(0);
+  }
+  if (args.scores) {
+    const hi = getHighScore();
+    const top = getTopScores();
+    console.log(`
+  High Score: ${hi}
+`);
+    if (top.length > 0) {
+      console.log("  Top Scores:");
+      top.forEach((s, i) => {
+        console.log(`    ${i + 1}. ${String(s.score).padStart(5, "0")}  (${s.date.split("T")[0]})`);
+      });
+      console.log();
+    }
+    process.exit(0);
+  }
+  if (args.install) {
+    if (args.install === "claude") installClaudeHook();
+    else if (args.install === "copilot") installCopilotPlugin();
+    else console.log("  Unknown target. Use: claude, copilot");
+    process.exit(0);
+  }
+  if (args.uninstall) {
+    if (args.uninstall === "claude") uninstallClaudeHook();
+    else if (args.uninstall === "copilot") uninstallCopilotPlugin();
+    else console.log("  Unknown target. Use: claude, copilot");
+    process.exit(0);
+  }
+  if (args.reset) {
+    resetScores();
+    console.log("  Scores reset.");
+    process.exit(0);
+  }
+  const options = {
+    source: args.trigger ?? "cli",
+    reason: args.reason
+  };
+  try {
+    const result = await startGame(options);
+    console.log(`
+  Score: ${result.score}  |  High Score: ${result.highScore}`);
+    if (result.isNewHighScore) {
+      console.log("  New high score!");
+    }
+    console.log();
+  } catch (err) {
+    console.error(`  Error: ${err.message}`);
+    process.exit(1);
+  }
+  process.exit(0);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cli
+});