atari 0.0.1-alpha.1 → 1.0.0

package/README.md

@@ -0,0 +1,59 @@
+# atari
+
+Retro Atari games in your terminal. Play classic arcade games like Snake, Pong, and Breakout directly from your command line.
+
+## Installation
+
+```bash
+npm install -g atari
+```
+
+## Usage
+
+```bash
+# Launch interactive menu
+atari
+
+# Play a specific game directly
+atari snake
+atari pong
+atari breakout
+
+# List available games
+atari --list
+
+# Show help
+atari --help
+```
+
+## Games
+
+- **Snake** - Classic snake game, eat food and grow longer
+- **Pong** - The original Atari hit, bounce the ball
+- **Breakout** - Break the bricks with your paddle
+
+## Controls
+
+| Key | Action |
+|-----|--------|
+| Arrow keys / WASD | Move |
+| Space | Action (shoot, pause) |
+| Q | Quit game |
+| R | Restart |
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run in development mode
+bun run dev
+
+# Build for production
+bun run build
+```
+
+## License
+
+MIT

package/bin/atari.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.mjs";

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export { };

package/dist/index.mjs

@@ -0,0 +1,812 @@
+import { defineCommand, runMain } from 'citty';
+import figlet from 'figlet';
+import pc from 'picocolors';
+import { intro, select, isCancel, outro, spinner } from '@clack/prompts';
+import { stdout, stdin } from 'process';
+
+async function showBanner() {
+  return new Promise((resolve, reject) => {
+    figlet.text(
+      "ATARI",
+      {
+        font: "ANSI Shadow",
+        horizontalLayout: "default",
+        verticalLayout: "default"
+      },
+      (err, data) => {
+        if (err) {
+          console.log(pc.bold(pc.red("\n  ATARI ARCADE\n")));
+          resolve();
+          return;
+        }
+        console.log(pc.red(data));
+        console.log(pc.dim("  Retro games in your terminal\n"));
+        resolve();
+      }
+    );
+  });
+}
+
+const ANSI = {
+  // Cursor
+  hideCursor: "\x1B[?25l",
+  showCursor: "\x1B[?25h",
+  moveTo: (x, y) => `\x1B[${y};${x}H`,
+  moveToStart: "\x1B[H",
+  // Screen
+  clearScreen: "\x1B[2J",
+  clearLine: "\x1B[2K",
+  // Colors (foreground)
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  black: "\x1B[30m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  // Background
+  bgBlack: "\x1B[40m",
+  bgRed: "\x1B[41m",
+  bgGreen: "\x1B[42m",
+  bgYellow: "\x1B[43m",
+  bgBlue: "\x1B[44m",
+  bgMagenta: "\x1B[45m",
+  bgCyan: "\x1B[46m",
+  bgWhite: "\x1B[47m"
+};
+function getScreenSize() {
+  return {
+    width: stdout.columns || 80,
+    height: stdout.rows || 24
+  };
+}
+function clearScreen() {
+  stdout.write(ANSI.clearScreen + ANSI.moveToStart);
+}
+function hideCursor() {
+  stdout.write(ANSI.hideCursor);
+}
+function showCursor() {
+  stdout.write(ANSI.showCursor);
+}
+function writeAt(x, y, text) {
+  stdout.write(ANSI.moveTo(x, y) + text);
+}
+function drawBox(x, y, width, height, color = ANSI.white) {
+  const horizontal = "\u2500".repeat(width - 2);
+  const top = `\u250C${horizontal}\u2510`;
+  const bottom = `\u2514${horizontal}\u2518`;
+  writeAt(x, y, color + top + ANSI.reset);
+  for (let i = 1; i < height - 1; i++) {
+    writeAt(x, y + i, color + "\u2502" + ANSI.reset);
+    writeAt(x + width - 1, y + i, color + "\u2502" + ANSI.reset);
+  }
+  writeAt(x, y + height - 1, color + bottom + ANSI.reset);
+}
+
+const KEY_CODES = {
+  // Arrow keys
+  "\x1B[A": "up",
+  "\x1B[B": "down",
+  "\x1B[C": "right",
+  "\x1B[D": "left",
+  // WASD
+  w: "up",
+  W: "up",
+  a: "left",
+  A: "left",
+  s: "down",
+  S: "down",
+  d: "right",
+  D: "right",
+  // Special keys
+  " ": "space",
+  "\r": "enter",
+  "\x1B": "escape",
+  q: "q",
+  Q: "q",
+  r: "r",
+  R: "r",
+  p: "p",
+  P: "p"
+};
+let isListening = false;
+let currentHandler = null;
+function parseKey(data) {
+  const str = data.toString();
+  return KEY_CODES[str] || "unknown";
+}
+function startKeyboardListener(handler) {
+  if (isListening) {
+    stopKeyboardListener();
+  }
+  currentHandler = handler;
+  isListening = true;
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  stdin.on("data", onKeyPress);
+}
+function stopKeyboardListener() {
+  if (!isListening) return;
+  stdin.off("data", onKeyPress);
+  stdin.setRawMode(false);
+  stdin.pause();
+  currentHandler = null;
+  isListening = false;
+}
+function onKeyPress(data) {
+  if (!currentHandler) return;
+  const key = parseKey(data);
+  if (data.toString() === "") {
+    stopKeyboardListener();
+    process.exit(0);
+  }
+  currentHandler(key, data);
+}
+
+function beep() {
+  stdout.write("\x07");
+}
+
+const MAX_WIDTH$2 = 40;
+const MAX_HEIGHT$2 = 18;
+const INITIAL_SPEED = 120;
+const VERTICAL_MULTIPLIER = 1.8;
+const SPEED_INCREMENT = 5;
+const snake = {
+  name: "Snake",
+  description: "Classic snake game - eat food and grow longer",
+  async start() {
+    const screen = getScreenSize();
+    const gameWidth = Math.min(MAX_WIDTH$2, screen.width - 4);
+    const gameHeight = Math.min(MAX_HEIGHT$2, screen.height - 8);
+    const offsetX = Math.max(1, Math.floor((screen.width - gameWidth - 2) / 2));
+    const offsetY = Math.max(2, Math.floor((screen.height - gameHeight - 4) / 2));
+    const state = {
+      snake: [{ x: Math.floor(gameWidth / 2), y: Math.floor(gameHeight / 2) }],
+      food: { x: 0, y: 0 },
+      direction: "right",
+      nextDirection: "right",
+      score: 0,
+      gameOver: false,
+      isPaused: false,
+      speed: INITIAL_SPEED,
+      gameWidth,
+      gameHeight
+    };
+    placeFood();
+    function placeFood() {
+      let newFood;
+      do {
+        newFood = {
+          x: Math.floor(Math.random() * state.gameWidth),
+          y: Math.floor(Math.random() * state.gameHeight)
+        };
+      } while (state.snake.some((s) => s.x === newFood.x && s.y === newFood.y));
+      state.food = newFood;
+    }
+    hideCursor();
+    clearScreen();
+    drawBox(offsetX, offsetY, gameWidth + 2, gameHeight + 2, ANSI.cyan);
+    writeAt(offsetX + Math.floor(gameWidth / 2) - 2, offsetY - 1, ANSI.bold + ANSI.yellow + "SNAKE" + ANSI.reset);
+    let intervalId;
+    function getSpeed() {
+      const isVertical = state.direction === "up" || state.direction === "down";
+      return isVertical ? state.speed * VERTICAL_MULTIPLIER : state.speed;
+    }
+    function gameLoop() {
+      if (state.gameOver) {
+        renderGameOver();
+        return;
+      }
+      if (!state.isPaused) {
+        update();
+        render();
+      } else {
+        renderPaused();
+      }
+      clearInterval(intervalId);
+      intervalId = setInterval(gameLoop, getSpeed());
+    }
+    function update() {
+      state.direction = state.nextDirection;
+      const head = { ...state.snake[0] };
+      switch (state.direction) {
+        case "up":
+          head.y--;
+          break;
+        case "down":
+          head.y++;
+          break;
+        case "left":
+          head.x--;
+          break;
+        case "right":
+          head.x++;
+          break;
+      }
+      if (head.x < 0 || head.x >= gameWidth || head.y < 0 || head.y >= gameHeight) {
+        state.gameOver = true;
+        return;
+      }
+      if (state.snake.some((s) => s.x === head.x && s.y === head.y)) {
+        state.gameOver = true;
+        return;
+      }
+      state.snake.unshift(head);
+      if (head.x === state.food.x && head.y === state.food.y) {
+        state.score += 10;
+        state.speed = Math.max(40, state.speed - SPEED_INCREMENT);
+        beep();
+        placeFood();
+      } else {
+        state.snake.pop();
+      }
+    }
+    function render() {
+      for (let y = 1; y <= gameHeight; y++) {
+        writeAt(offsetX + 1, offsetY + y, " ".repeat(gameWidth));
+      }
+      writeAt(offsetX + state.food.x + 1, offsetY + state.food.y + 1, ANSI.red + "o" + ANSI.reset);
+      state.snake.forEach((segment, i) => {
+        const color = i === 0 ? ANSI.green : ANSI.cyan;
+        writeAt(offsetX + segment.x + 1, offsetY + segment.y + 1, color + "#" + ANSI.reset);
+      });
+      writeAt(offsetX, offsetY + gameHeight + 3, `${ANSI.yellow}Score: ${state.score}${ANSI.reset}  ${ANSI.dim}Q:Quit P:Pause${ANSI.reset}`);
+    }
+    function renderPaused() {
+      writeAt(offsetX + Math.floor(gameWidth / 2) - 3, offsetY + Math.floor(gameHeight / 2), ANSI.yellow + "PAUSED" + ANSI.reset);
+    }
+    function renderGameOver() {
+      const cx = offsetX + Math.floor(gameWidth / 2);
+      const cy = offsetY + Math.floor(gameHeight / 2);
+      writeAt(cx - 5, cy - 1, ANSI.red + ANSI.bold + "GAME OVER!" + ANSI.reset);
+      writeAt(cx - 5, cy + 1, `Score: ${ANSI.yellow}${state.score}${ANSI.reset}`);
+      writeAt(cx - 8, cy + 3, ANSI.dim + "R:Restart Q:Quit" + ANSI.reset);
+    }
+    function cleanup() {
+      clearInterval(intervalId);
+      stopKeyboardListener();
+      showCursor();
+      clearScreen();
+    }
+    function resetGame() {
+      state.snake = [{ x: Math.floor(gameWidth / 2), y: Math.floor(gameHeight / 2) }];
+      state.direction = "right";
+      state.nextDirection = "right";
+      state.score = 0;
+      state.gameOver = false;
+      state.isPaused = false;
+      state.speed = INITIAL_SPEED;
+      placeFood();
+      clearScreen();
+      drawBox(offsetX, offsetY, gameWidth + 2, gameHeight + 2, ANSI.cyan);
+      writeAt(offsetX + Math.floor(gameWidth / 2) - 2, offsetY - 1, ANSI.bold + ANSI.yellow + "SNAKE" + ANSI.reset);
+    }
+    intervalId = setInterval(gameLoop, state.speed);
+    return new Promise((resolve) => {
+      startKeyboardListener((key) => {
+        if (key === "q") {
+          cleanup();
+          resolve();
+          return;
+        }
+        if (key === "r" && state.gameOver) {
+          resetGame();
+          return;
+        }
+        if (key === "p" || key === "space") {
+          state.isPaused = !state.isPaused;
+          return;
+        }
+        if (key === "up" && state.direction !== "down") state.nextDirection = "up";
+        else if (key === "down" && state.direction !== "up") state.nextDirection = "down";
+        else if (key === "left" && state.direction !== "right") state.nextDirection = "left";
+        else if (key === "right" && state.direction !== "left") state.nextDirection = "right";
+      });
+    });
+  }
+};
+
+const MAX_WIDTH$1 = 50;
+const MAX_HEIGHT$1 = 18;
+const PADDLE_HEIGHT = 4;
+const WINNING_SCORE = 5;
+const FRAME_TIME$1 = 50;
+const AI_SPEED = 0.8;
+const pong = {
+  name: "Pong",
+  description: "The original Atari hit - bounce the ball",
+  async start() {
+    const screen = getScreenSize();
+    const gameWidth = Math.min(MAX_WIDTH$1, screen.width - 4);
+    const gameHeight = Math.min(MAX_HEIGHT$1, screen.height - 8);
+    const offsetX = Math.max(1, Math.floor((screen.width - gameWidth - 2) / 2));
+    const offsetY = Math.max(2, Math.floor((screen.height - gameHeight - 4) / 2));
+    const state = {
+      ballX: Math.floor(gameWidth / 2),
+      ballY: Math.floor(gameHeight / 2),
+      ballVX: Math.random() > 0.5 ? 0.8 : -0.8,
+      ballVY: (Math.random() - 0.5) * 0.8,
+      leftPaddleY: Math.floor((gameHeight - PADDLE_HEIGHT) / 2),
+      rightPaddleY: Math.floor((gameHeight - PADDLE_HEIGHT) / 2),
+      leftScore: 0,
+      rightScore: 0,
+      gameOver: false,
+      isPaused: false,
+      winner: null};
+    let moveUp = false;
+    let moveDown = false;
+    hideCursor();
+    clearScreen();
+    drawBox(offsetX, offsetY, gameWidth + 2, gameHeight + 2, ANSI.cyan);
+    writeAt(offsetX + Math.floor(gameWidth / 2) - 1, offsetY + gameHeight + 3, ANSI.bold + ANSI.yellow + "PONG" + ANSI.reset);
+    let intervalId;
+    function gameLoop() {
+      if (state.gameOver) {
+        renderGameOver();
+        return;
+      }
+      if (!state.isPaused) {
+        processInput();
+        updateAI();
+        update();
+        render();
+      } else {
+        renderPaused();
+      }
+    }
+    function processInput() {
+      if (moveUp) {
+        state.leftPaddleY = Math.max(0, state.leftPaddleY - 1);
+      }
+      if (moveDown) {
+        state.leftPaddleY = Math.min(gameHeight - PADDLE_HEIGHT, state.leftPaddleY + 1);
+      }
+    }
+    function updateAI() {
+      const paddleCenter = state.rightPaddleY + PADDLE_HEIGHT / 2;
+      const diff = state.ballY - paddleCenter;
+      if (state.ballVX > 0) {
+        if (diff > 1 && Math.random() < AI_SPEED) {
+          state.rightPaddleY = Math.min(gameHeight - PADDLE_HEIGHT, state.rightPaddleY + 1);
+        } else if (diff < -1 && Math.random() < AI_SPEED) {
+          state.rightPaddleY = Math.max(0, state.rightPaddleY - 1);
+        }
+      }
+    }
+    function update() {
+      state.ballX += state.ballVX;
+      state.ballY += state.ballVY;
+      if (state.ballY <= 0 || state.ballY >= gameHeight - 1) {
+        state.ballVY *= -1;
+        state.ballY = Math.max(0, Math.min(gameHeight - 1, state.ballY));
+      }
+      if (state.ballX <= 2 && state.ballY >= state.leftPaddleY && state.ballY < state.leftPaddleY + PADDLE_HEIGHT) {
+        state.ballVX = Math.abs(state.ballVX) * 1.05;
+        state.ballVX = Math.min(state.ballVX, 2);
+        const hitPos = (state.ballY - state.leftPaddleY) / PADDLE_HEIGHT;
+        state.ballVY = (hitPos - 0.5) * 1.5;
+        beep();
+      }
+      if (state.ballX >= gameWidth - 3 && state.ballY >= state.rightPaddleY && state.ballY < state.rightPaddleY + PADDLE_HEIGHT) {
+        state.ballVX = -Math.abs(state.ballVX) * 1.05;
+        state.ballVX = Math.max(state.ballVX, -2);
+        const hitPos = (state.ballY - state.rightPaddleY) / PADDLE_HEIGHT;
+        state.ballVY = (hitPos - 0.5) * 1.5;
+        beep();
+      }
+      if (state.ballX <= 0) {
+        state.rightScore++;
+        if (state.rightScore >= WINNING_SCORE) {
+          state.gameOver = true;
+          state.winner = "ai";
+        } else {
+          resetBall();
+        }
+      } else if (state.ballX >= gameWidth - 1) {
+        state.leftScore++;
+        if (state.leftScore >= WINNING_SCORE) {
+          state.gameOver = true;
+          state.winner = "player";
+        } else {
+          resetBall();
+        }
+      }
+    }
+    function resetBall() {
+      state.ballX = Math.floor(gameWidth / 2);
+      state.ballY = Math.floor(gameHeight / 2);
+      state.ballVX = (Math.random() > 0.5 ? 1 : -1) * 0.8;
+      state.ballVY = (Math.random() - 0.5) * 0.8;
+    }
+    function render() {
+      for (let y = 1; y <= gameHeight; y++) {
+        writeAt(offsetX + 1, offsetY + y, " ".repeat(gameWidth));
+      }
+      for (let y = 1; y <= gameHeight; y++) {
+        if (y % 2 === 0) {
+          writeAt(offsetX + Math.floor(gameWidth / 2) + 1, offsetY + y, ANSI.dim + ":" + ANSI.reset);
+        }
+      }
+      const bx = Math.round(state.ballX);
+      const by = Math.round(state.ballY);
+      if (bx >= 0 && bx < gameWidth && by >= 0 && by < gameHeight) {
+        writeAt(offsetX + bx + 1, offsetY + by + 1, ANSI.white + "o" + ANSI.reset);
+      }
+      for (let i = 0; i < PADDLE_HEIGHT; i++) {
+        const py = state.leftPaddleY + i;
+        if (py >= 0 && py < gameHeight) {
+          writeAt(offsetX + 2, offsetY + py + 1, ANSI.green + "#" + ANSI.reset);
+        }
+      }
+      for (let i = 0; i < PADDLE_HEIGHT; i++) {
+        const py = state.rightPaddleY + i;
+        if (py >= 0 && py < gameHeight) {
+          writeAt(offsetX + gameWidth - 1, offsetY + py + 1, ANSI.red + "#" + ANSI.reset);
+        }
+      }
+      writeAt(offsetX + Math.floor(gameWidth / 4), offsetY - 1, ANSI.green + state.leftScore.toString() + ANSI.reset);
+      writeAt(offsetX + Math.floor(3 * gameWidth / 4), offsetY - 1, ANSI.red + state.rightScore.toString() + ANSI.reset);
+      writeAt(
+        offsetX,
+        offsetY + gameHeight + 3,
+        `${ANSI.dim}W/S or Arrows: Move | Q: Quit | P: Pause${ANSI.reset}`
+      );
+    }
+    function renderPaused() {
+      writeAt(
+        offsetX + Math.floor(gameWidth / 2) - 3,
+        offsetY + Math.floor(gameHeight / 2),
+        ANSI.yellow + "PAUSED" + ANSI.reset
+      );
+    }
+    function renderGameOver() {
+      const cx = offsetX + Math.floor(gameWidth / 2);
+      const cy = offsetY + Math.floor(gameHeight / 2);
+      if (state.winner === "player") {
+        writeAt(cx - 4, cy - 1, ANSI.green + ANSI.bold + "YOU WIN!" + ANSI.reset);
+      } else {
+        writeAt(cx - 4, cy - 1, ANSI.red + ANSI.bold + "AI WINS!" + ANSI.reset);
+      }
+      writeAt(cx - 7, cy + 1, `${ANSI.green}${state.leftScore}${ANSI.reset} - ${ANSI.red}${state.rightScore}${ANSI.reset}`);
+      writeAt(cx - 8, cy + 3, ANSI.dim + "R:Restart Q:Quit" + ANSI.reset);
+    }
+    function cleanup() {
+      clearInterval(intervalId);
+      stopKeyboardListener();
+      showCursor();
+      clearScreen();
+    }
+    function resetGame() {
+      state.ballX = Math.floor(gameWidth / 2);
+      state.ballY = Math.floor(gameHeight / 2);
+      state.ballVX = (Math.random() > 0.5 ? 1 : -1) * 0.8;
+      state.ballVY = (Math.random() - 0.5) * 0.8;
+      state.leftPaddleY = Math.floor((gameHeight - PADDLE_HEIGHT) / 2);
+      state.rightPaddleY = Math.floor((gameHeight - PADDLE_HEIGHT) / 2);
+      state.leftScore = 0;
+      state.rightScore = 0;
+      state.gameOver = false;
+      state.isPaused = false;
+      state.winner = null;
+      clearScreen();
+      drawBox(offsetX, offsetY, gameWidth + 2, gameHeight + 2, ANSI.cyan);
+      writeAt(offsetX + Math.floor(gameWidth / 2) - 1, offsetY + gameHeight + 3, ANSI.bold + ANSI.yellow + "PONG" + ANSI.reset);
+    }
+    intervalId = setInterval(gameLoop, FRAME_TIME$1);
+    return new Promise((resolve) => {
+      startKeyboardListener((key) => {
+        if (key === "q") {
+          cleanup();
+          resolve();
+          return;
+        }
+        if (key === "r" && state.gameOver) {
+          resetGame();
+          return;
+        }
+        if (key === "p") {
+          state.isPaused = !state.isPaused;
+          return;
+        }
+        if (key === "up") {
+          moveUp = true;
+          setTimeout(() => moveUp = false, FRAME_TIME$1 * 2);
+        }
+        if (key === "down") {
+          moveDown = true;
+          setTimeout(() => moveDown = false, FRAME_TIME$1 * 2);
+        }
+      });
+    });
+  }
+};
+
+const MAX_WIDTH = 44;
+const MAX_HEIGHT = 20;
+const PADDLE_WIDTH = 8;
+const BRICK_WIDTH = 4;
+const BRICK_ROWS = 4;
+const FRAME_TIME = 50;
+const BRICK_COLORS = [
+  { color: ANSI.red, points: 40 },
+  { color: ANSI.yellow, points: 30 },
+  { color: ANSI.green, points: 20 },
+  { color: ANSI.cyan, points: 10 }
+];
+const breakout = {
+  name: "Breakout",
+  description: "Break the bricks with your paddle",
+  async start() {
+    const screen = getScreenSize();
+    const gameWidth = Math.min(MAX_WIDTH, screen.width - 4);
+    const gameHeight = Math.min(MAX_HEIGHT, screen.height - 8);
+    const offsetX = Math.max(1, Math.floor((screen.width - gameWidth - 2) / 2));
+    const offsetY = Math.max(2, Math.floor((screen.height - gameHeight - 4) / 2));
+    const bricksPerRow = Math.floor((gameWidth - 2) / (BRICK_WIDTH + 1));
+    function createBricks() {
+      const bricks = [];
+      for (let row = 0; row < BRICK_ROWS; row++) {
+        const { color, points } = BRICK_COLORS[row % BRICK_COLORS.length];
+        for (let col = 0; col < bricksPerRow; col++) {
+          bricks.push({
+            x: 1 + col * (BRICK_WIDTH + 1),
+            y: 2 + row,
+            color,
+            points,
+            destroyed: false
+          });
+        }
+      }
+      return bricks;
+    }
+    const state = {
+      ballX: Math.floor(gameWidth / 2),
+      ballY: gameHeight - 4,
+      ballVX: 0.5,
+      ballVY: -0.5,
+      paddleX: Math.floor((gameWidth - PADDLE_WIDTH) / 2),
+      bricks: createBricks(),
+      score: 0,
+      lives: 3,
+      gameOver: false,
+      isPaused: false,
+      won: false};
+    let moveLeft = false;
+    let moveRight = false;
+    hideCursor();
+    clearScreen();
+    drawBox(offsetX, offsetY, gameWidth + 2, gameHeight + 2, ANSI.cyan);
+    writeAt(offsetX + Math.floor(gameWidth / 2) - 3, offsetY - 1, ANSI.bold + ANSI.yellow + "BREAKOUT" + ANSI.reset);
+    let intervalId;
+    function gameLoop() {
+      if (state.gameOver) {
+        renderGameOver();
+        return;
+      }
+      if (!state.isPaused) {
+        processInput();
+        update();
+        render();
+      } else {
+        renderPaused();
+      }
+    }
+    function processInput() {
+      if (moveLeft) {
+        state.paddleX = Math.max(0, state.paddleX - 2);
+      }
+      if (moveRight) {
+        state.paddleX = Math.min(gameWidth - PADDLE_WIDTH, state.paddleX + 2);
+      }
+    }
+    function update() {
+      state.ballX += state.ballVX;
+      state.ballY += state.ballVY;
+      if (state.ballX <= 0 || state.ballX >= gameWidth - 1) {
+        state.ballVX *= -1;
+        state.ballX = Math.max(0, Math.min(gameWidth - 1, state.ballX));
+      }
+      if (state.ballY <= 0) {
+        state.ballVY *= -1;
+        state.ballY = 0;
+      }
+      if (state.ballY >= gameHeight - 2 && state.ballY < gameHeight && state.ballX >= state.paddleX - 1 && state.ballX <= state.paddleX + PADDLE_WIDTH) {
+        state.ballVY = -Math.abs(state.ballVY);
+        const hitPos = (state.ballX - state.paddleX) / PADDLE_WIDTH;
+        state.ballVX = (hitPos - 0.5) * 1.5;
+        state.ballY = gameHeight - 3;
+        beep();
+      }
+      if (state.ballY >= gameHeight) {
+        state.lives--;
+        if (state.lives <= 0) {
+          state.gameOver = true;
+          state.won = false;
+        } else {
+          resetBall();
+        }
+      }
+      const bx = Math.round(state.ballX);
+      const by = Math.round(state.ballY);
+      for (const brick of state.bricks) {
+        if (brick.destroyed) continue;
+        if (bx >= brick.x && bx < brick.x + BRICK_WIDTH && by === brick.y) {
+          brick.destroyed = true;
+          state.score += brick.points;
+          state.ballVY *= -1;
+          beep();
+          if (state.bricks.every((b) => b.destroyed)) {
+            state.gameOver = true;
+            state.won = true;
+          }
+          break;
+        }
+      }
+    }
+    function resetBall() {
+      state.ballX = Math.floor(gameWidth / 2);
+      state.ballY = gameHeight - 4;
+      state.ballVX = (Math.random() > 0.5 ? 1 : -1) * 0.5;
+      state.ballVY = -0.5;
+    }
+    function render() {
+      for (let y = 1; y <= gameHeight; y++) {
+        writeAt(offsetX + 1, offsetY + y, " ".repeat(gameWidth));
+      }
+      for (const brick of state.bricks) {
+        if (brick.destroyed) continue;
+        writeAt(offsetX + brick.x + 1, offsetY + brick.y + 1, brick.color + "=".repeat(BRICK_WIDTH) + ANSI.reset);
+      }
+      const bx = Math.round(state.ballX);
+      const by = Math.round(state.ballY);
+      if (bx >= 0 && bx < gameWidth && by >= 0 && by < gameHeight) {
+        writeAt(offsetX + bx + 1, offsetY + by + 1, ANSI.white + "o" + ANSI.reset);
+      }
+      writeAt(offsetX + state.paddleX + 1, offsetY + gameHeight, ANSI.green + "=".repeat(PADDLE_WIDTH) + ANSI.reset);
+      const hearts = ANSI.red + "\u2665".repeat(state.lives) + ANSI.reset;
+      writeAt(offsetX, offsetY + gameHeight + 3, `${ANSI.yellow}Score: ${state.score}${ANSI.reset} | ${hearts} | ${ANSI.dim}Q:Quit P:Pause${ANSI.reset}`);
+    }
+    function renderPaused() {
+      writeAt(offsetX + Math.floor(gameWidth / 2) - 3, offsetY + Math.floor(gameHeight / 2), ANSI.yellow + "PAUSED" + ANSI.reset);
+    }
+    function renderGameOver() {
+      const cx = offsetX + Math.floor(gameWidth / 2);
+      const cy = offsetY + Math.floor(gameHeight / 2);
+      if (state.won) {
+        writeAt(cx - 4, cy - 1, ANSI.green + ANSI.bold + "YOU WIN!" + ANSI.reset);
+      } else {
+        writeAt(cx - 5, cy - 1, ANSI.red + ANSI.bold + "GAME OVER!" + ANSI.reset);
+      }
+      writeAt(cx - 5, cy + 1, `Score: ${ANSI.yellow}${state.score}${ANSI.reset}`);
+      writeAt(cx - 8, cy + 3, ANSI.dim + "R:Restart Q:Quit" + ANSI.reset);
+    }
+    function cleanup() {
+      clearInterval(intervalId);
+      stopKeyboardListener();
+      showCursor();
+      clearScreen();
+    }
+    function resetGame() {
+      state.ballX = Math.floor(gameWidth / 2);
+      state.ballY = gameHeight - 4;
+      state.ballVX = (Math.random() > 0.5 ? 1 : -1) * 0.5;
+      state.ballVY = -0.5;
+      state.paddleX = Math.floor((gameWidth - PADDLE_WIDTH) / 2);
+      state.bricks = createBricks();
+      state.score = 0;
+      state.lives = 3;
+      state.gameOver = false;
+      state.isPaused = false;
+      state.won = false;
+      clearScreen();
+      drawBox(offsetX, offsetY, gameWidth + 2, gameHeight + 2, ANSI.cyan);
+      writeAt(offsetX + Math.floor(gameWidth / 2) - 3, offsetY - 1, ANSI.bold + ANSI.yellow + "BREAKOUT" + ANSI.reset);
+    }
+    intervalId = setInterval(gameLoop, FRAME_TIME);
+    return new Promise((resolve) => {
+      startKeyboardListener((key) => {
+        if (key === "q") {
+          cleanup();
+          resolve();
+          return;
+        }
+        if (key === "r" && state.gameOver) {
+          resetGame();
+          return;
+        }
+        if (key === "p" || key === "space") {
+          state.isPaused = !state.isPaused;
+          return;
+        }
+        if (key === "left") {
+          moveLeft = true;
+          setTimeout(() => moveLeft = false, FRAME_TIME * 2);
+        }
+        if (key === "right") {
+          moveRight = true;
+          setTimeout(() => moveRight = false, FRAME_TIME * 2);
+        }
+      });
+    });
+  }
+};
+
+const games = {
+  snake,
+  pong,
+  breakout
+};
+
+async function showMenu() {
+  intro(pc.inverse(" Welcome to Atari Arcade! "));
+  const gameOptions = Object.entries(games).map(([key, game]) => ({
+    value: key,
+    label: game.name,
+    hint: game.description
+  }));
+  const selectedGame = await select({
+    message: "Choose your game:",
+    options: gameOptions
+  });
+  if (isCancel(selectedGame)) {
+    outro(pc.dim("Thanks for visiting!"));
+    process.exit(0);
+  }
+  const s = spinner();
+  s.start("Loading game...");
+  await new Promise((r) => setTimeout(r, 300));
+  s.stop("Game loaded!");
+  await games[selectedGame].start();
+  outro(pc.green("Thanks for playing!"));
+}
+
+const main = defineCommand({
+  meta: {
+    name: "atari",
+    version: "1.0.0",
+    description: "Retro Atari games in your terminal"
+  },
+  args: {
+    game: {
+      type: "positional",
+      description: "Game to play (snake, pong, breakout)",
+      required: false
+    },
+    list: {
+      type: "boolean",
+      alias: "l",
+      description: "List available games"
+    }
+  },
+  async run({ args }) {
+    await showBanner();
+    if (args.list) {
+      console.log("\nAvailable games:");
+      for (const [key, game] of Object.entries(games)) {
+        console.log(`  - ${key}: ${game.description}`);
+      }
+      console.log("\nUsage: atari <game>");
+      return;
+    }
+    if (args.game) {
+      const gameKey = args.game;
+      if (games[gameKey]) {
+        await games[gameKey].start();
+      } else {
+        console.error(`Unknown game: ${args.game}`);
+        console.log("Available games: " + Object.keys(games).join(", "));
+        process.exit(1);
+      }
+    } else {
+      await showMenu();
+    }
+  }
+});
+runMain(main);

package/package.json

@@ -1,7 +1,51 @@
 {
   "name": "atari",
-  "version": "0.0.1-alpha.1",
-  "description": "Placeholder for an upcoming project",
-  "main": "index.js",
-  "license": "MIT"
-}
+  "version": "1.0.0",
+  "description": "Retro Atari games in your terminal",
+  "type": "module",
+  "bin": {
+    "atari": "./bin/atari.mjs"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "atari",
+    "games",
+    "terminal",
+    "cli",
+    "retro",
+    "arcade",
+    "snake",
+    "pong",
+    "breakout"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "citty": "^0.2.0",
+    "figlet": "^1.8.0",
+    "picocolors": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "unbuild": "^3.5.0"
+  }
+}

package/index.js

@@ -1 +0,0 @@
-// placeholder