@compilr-dev/cli 0.4.0 → 0.5.1

package/dist/games/game-base.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Base class for terminal games
+ *
+ * Handles alternate screen, raw input, game loop, and clean exit.
+ */
+import { EventEmitter } from 'events';
+export interface GameConfig {
+    title: string;
+    minWidth: number;
+    minHeight: number;
+    targetFps: number;
+}
+export declare abstract class GameBase extends EventEmitter {
+    protected config: GameConfig;
+    protected running: boolean;
+    protected paused: boolean;
+    protected gameLoopInterval: ReturnType<typeof setInterval> | null;
+    protected lastFrameTime: number;
+    protected stdin: NodeJS.ReadStream;
+    protected stdout: NodeJS.WriteStream;
+    constructor(config: GameConfig);
+    /**
+     * Check if terminal is large enough
+     */
+    protected checkTerminalSize(): {
+        ok: boolean;
+        message?: string;
+    };
+    /**
+     * Enter alternate screen buffer
+     */
+    protected enterAlternateScreen(): void;
+    /**
+     * Exit alternate screen buffer
+     */
+    protected exitAlternateScreen(): void;
+    /**
+     * Set up raw input mode
+     */
+    protected setupInput(): void;
+    /**
+     * Restore normal input mode
+     */
+    protected restoreInput(): void;
+    /**
+     * Handle raw input data
+     */
+    private handleInput;
+    /**
+     * Start the game loop
+     */
+    protected startGameLoop(): void;
+    /**
+     * Stop the game loop
+     */
+    protected stopGameLoop(): void;
+    /**
+     * Move cursor to position
+     */
+    protected moveCursor(x: number, y: number): void;
+    /**
+     * Write text at position
+     */
+    protected writeAt(x: number, y: number, text: string): void;
+    /**
+     * Clear screen
+     */
+    protected clearScreen(): void;
+    /**
+     * Start the game
+     */
+    start(): Promise<void>;
+    /**
+     * Quit the game
+     */
+    quit(): void;
+    protected abstract onStart(): void;
+    protected abstract onQuit(): void;
+    protected abstract onPause(): void;
+    protected abstract onResume(): void;
+    protected abstract onKeyPress(key: string, raw: Buffer): void;
+    protected abstract update(delta: number): void;
+    protected abstract render(): void;
+}

package/dist/games/game-base.js

@@ -0,0 +1,204 @@
+/**
+ * Base class for terminal games
+ *
+ * Handles alternate screen, raw input, game loop, and clean exit.
+ */
+import { EventEmitter } from 'events';
+export class GameBase extends EventEmitter {
+    config;
+    running = false;
+    paused = false;
+    gameLoopInterval = null;
+    lastFrameTime = 0;
+    stdin;
+    stdout;
+    constructor(config) {
+        super();
+        this.config = config;
+        this.stdin = process.stdin;
+        this.stdout = process.stdout;
+    }
+    /**
+     * Check if terminal is large enough
+     */
+    checkTerminalSize() {
+        const cols = this.stdout.columns || 80;
+        const rows = this.stdout.rows || 24;
+        if (cols < this.config.minWidth || rows < this.config.minHeight) {
+            return {
+                ok: false,
+                message: `Terminal too small. Need ${String(this.config.minWidth)}x${String(this.config.minHeight)}, got ${String(cols)}x${String(rows)}`,
+            };
+        }
+        return { ok: true };
+    }
+    /**
+     * Enter alternate screen buffer
+     */
+    enterAlternateScreen() {
+        // Save cursor position and switch to alternate buffer
+        this.stdout.write('\x1b[?1049h');
+        // Hide cursor
+        this.stdout.write('\x1b[?25l');
+        // Clear screen
+        this.stdout.write('\x1b[2J');
+        // Move to top-left
+        this.stdout.write('\x1b[H');
+    }
+    /**
+     * Exit alternate screen buffer
+     */
+    exitAlternateScreen() {
+        // Clear the alternate screen first to prevent flash
+        this.stdout.write('\x1b[2J\x1b[H');
+        // Show cursor
+        this.stdout.write('\x1b[?25h');
+        // Restore main buffer
+        this.stdout.write('\x1b[?1049l');
+    }
+    /**
+     * Set up raw input mode
+     */
+    setupInput() {
+        if (this.stdin.isTTY) {
+            this.stdin.setRawMode(true);
+        }
+        this.stdin.resume();
+        this.stdin.on('data', this.handleInput.bind(this));
+    }
+    /**
+     * Restore normal input mode
+     */
+    restoreInput() {
+        this.stdin.removeAllListeners('data');
+        // Pause to prevent any buffered input from leaking
+        this.stdin.pause();
+        if (this.stdin.isTTY) {
+            this.stdin.setRawMode(false);
+        }
+    }
+    /**
+     * Handle raw input data
+     */
+    handleInput(data) {
+        const key = data.toString();
+        // Check for quit keys first
+        // q or Ctrl+C always quit
+        if (key === 'q' || key === '\x03') {
+            this.quit();
+            return;
+        }
+        // Standalone Escape quits (but not escape sequences like arrow keys \x1b[A)
+        // Escape is a single byte (0x1b), arrow keys are 3+ bytes
+        if (data.length === 1 && data[0] === 0x1b) {
+            this.quit();
+            return;
+        }
+        // Pause/unpause
+        if (key === 'p') {
+            this.paused = !this.paused;
+            if (this.paused) {
+                this.onPause();
+            }
+            else {
+                this.onResume();
+            }
+            return;
+        }
+        // Pass to game-specific handler
+        if (!this.paused) {
+            this.onKeyPress(key, data);
+        }
+    }
+    /**
+     * Start the game loop
+     */
+    startGameLoop() {
+        const frameInterval = 1000 / this.config.targetFps;
+        this.lastFrameTime = Date.now();
+        this.gameLoopInterval = setInterval(() => {
+            if (!this.paused && this.running) {
+                const now = Date.now();
+                const delta = now - this.lastFrameTime;
+                this.lastFrameTime = now;
+                this.update(delta);
+                this.render();
+            }
+        }, frameInterval);
+    }
+    /**
+     * Stop the game loop
+     */
+    stopGameLoop() {
+        if (this.gameLoopInterval) {
+            clearInterval(this.gameLoopInterval);
+            this.gameLoopInterval = null;
+        }
+    }
+    /**
+     * Move cursor to position
+     */
+    moveCursor(x, y) {
+        this.stdout.write(`\x1b[${String(y)};${String(x)}H`);
+    }
+    /**
+     * Write text at position
+     */
+    writeAt(x, y, text) {
+        this.moveCursor(x, y);
+        this.stdout.write(text);
+    }
+    /**
+     * Clear screen
+     */
+    clearScreen() {
+        this.stdout.write('\x1b[2J\x1b[H');
+    }
+    /**
+     * Start the game
+     */
+    async start() {
+        // Check terminal size
+        const sizeCheck = this.checkTerminalSize();
+        if (!sizeCheck.ok) {
+            console.log(sizeCheck.message);
+            return;
+        }
+        // Set up signal handlers for clean exit
+        const cleanup = () => {
+            this.quit();
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        try {
+            this.running = true;
+            this.enterAlternateScreen();
+            this.setupInput();
+            this.onStart();
+            this.startGameLoop();
+            // Wait for game to end
+            await new Promise((resolve) => {
+                this.once('quit', resolve);
+            });
+        }
+        finally {
+            process.removeListener('SIGINT', cleanup);
+            process.removeListener('SIGTERM', cleanup);
+            this.stopGameLoop();
+            this.restoreInput();
+            this.exitAlternateScreen();
+            // Small delay to ensure terminal state is fully restored
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
+    /**
+     * Quit the game
+     */
+    quit() {
+        if (this.running) {
+            this.running = false;
+            this.onQuit();
+            this.emit('quit');
+        }
+    }
+}

package/dist/games/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Games Module
+ *
+ * Entry point for the terminal games easter egg.
+ */
+export { playTetris, TetrisGame } from './tetris/index.js';
+export { getCoins, hasCoins, spendCoins, earnCoins, checkDailyBonus, formatCoinsDisplay, getCoinsDisplayShort, COIN_COST_START_GAME, COIN_COST_CONTINUE } from './coins.js';
+export { getHighScores, isLeaderboardScore, isNewHighScore, getBestScore, formatScore, formatHighScoreEntry } from './scores.js';
+export interface GameInfo {
+    id: string;
+    name: string;
+    description: string;
+    available: boolean;
+    play: () => Promise<void>;
+}
+export declare function getAvailableGames(): GameInfo[];

package/dist/games/index.js

@@ -0,0 +1,49 @@
+/**
+ * Games Module
+ *
+ * Entry point for the terminal games easter egg.
+ */
+export { playTetris, TetrisGame } from './tetris/index.js';
+export { getCoins, hasCoins, spendCoins, earnCoins, checkDailyBonus, formatCoinsDisplay, getCoinsDisplayShort, COIN_COST_START_GAME, COIN_COST_CONTINUE } from './coins.js';
+export { getHighScores, isLeaderboardScore, isNewHighScore, getBestScore, formatScore, formatHighScoreEntry } from './scores.js';
+export function getAvailableGames() {
+    return [
+        {
+            id: 'tetris',
+            name: 'TETRIS',
+            description: 'Classic block-stacking puzzle',
+            available: true,
+            play: async () => {
+                const { playTetris } = await import('./tetris/index.js');
+                await playTetris();
+            },
+        },
+        {
+            id: 'snake',
+            name: 'SNAKE',
+            description: 'Eat food, grow longer',
+            available: false,
+            play: async () => {
+                // Coming soon
+            },
+        },
+        {
+            id: 'invaders',
+            name: 'SPACE INVADERS',
+            description: 'Defend Earth from aliens',
+            available: false,
+            play: async () => {
+                // Coming soon
+            },
+        },
+        {
+            id: 'breakout',
+            name: 'BREAKOUT',
+            description: 'Break all the bricks',
+            available: false,
+            play: async () => {
+                // Coming soon
+            },
+        },
+    ];
+}

package/dist/games/scores.d.ts

@@ -0,0 +1,69 @@
+/**
+ * High Scores System
+ *
+ * Manages high scores for all games.
+ */
+export interface HighScore {
+    name: string;
+    score: number;
+    level: number;
+    date: string;
+}
+export interface ScoresData {
+    [gameId: string]: HighScore[];
+}
+/**
+ * Get all scores data
+ */
+export declare function getScoresData(): ScoresData;
+/**
+ * Get high scores for a specific game
+ */
+export declare function getHighScores(gameId: string): HighScore[];
+/**
+ * Check if a score qualifies for the leaderboard (top 10)
+ */
+export declare function isLeaderboardScore(gameId: string, score: number): boolean;
+/**
+ * Check if a score beats the current high score (#1)
+ * This is the "NEW HIGH SCORE!" condition for coin award
+ */
+export declare function isNewHighScore(gameId: string, score: number): boolean;
+/**
+ * Check if a score qualifies for the leaderboard
+ * @deprecated Use isLeaderboardScore for top-10 check, isNewHighScore for #1 check
+ */
+export declare function isHighScore(gameId: string, score: number): boolean;
+/**
+ * Get the rank a score would achieve (1-based, or null if not a high score)
+ */
+export declare function getScoreRank(gameId: string, score: number): number | null;
+/**
+ * Add a new high score
+ * Returns the rank achieved (1-based) or null if didn't make the leaderboard
+ */
+export declare function addHighScore(gameId: string, name: string, score: number, level: number): number | null;
+/**
+ * Get the player's best score for a game
+ */
+export declare function getBestScore(gameId: string): HighScore | null;
+/**
+ * Clear high scores for a game (for testing)
+ */
+export declare function clearHighScores(gameId: string): void;
+/**
+ * Clear all high scores (for testing)
+ */
+export declare function clearAllHighScores(): void;
+/**
+ * Clear cache (for testing)
+ */
+export declare function clearScoresCache(): void;
+/**
+ * Format a score number with commas
+ */
+export declare function formatScore(score: number): string;
+/**
+ * Format a high score entry for display
+ */
+export declare function formatHighScoreEntry(rank: number, entry: HighScore, maxScoreWidth?: number): string;

package/dist/games/scores.js

@@ -0,0 +1,191 @@
+/**
+ * High Scores System
+ *
+ * Manages high scores for all games.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// =============================================================================
+// Constants
+// =============================================================================
+const CONFIG_DIR = path.join(os.homedir(), '.compilr-dev');
+const SCORES_FILE = path.join(CONFIG_DIR, 'highscores.json');
+const MAX_SCORES_PER_GAME = 10;
+// =============================================================================
+// In-memory cache
+// =============================================================================
+let scoresCache = null;
+// =============================================================================
+// Persistence
+// =============================================================================
+function loadFromDisk() {
+    try {
+        if (fs.existsSync(SCORES_FILE)) {
+            const data = fs.readFileSync(SCORES_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return {};
+}
+function saveToDisk(data) {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(SCORES_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to save high scores:', error);
+    }
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Get all scores data
+ */
+export function getScoresData() {
+    if (scoresCache) {
+        return scoresCache;
+    }
+    scoresCache = loadFromDisk();
+    return scoresCache;
+}
+/**
+ * Get high scores for a specific game
+ */
+export function getHighScores(gameId) {
+    const data = getScoresData();
+    return data[gameId] ?? [];
+}
+/**
+ * Check if a score qualifies for the leaderboard (top 10)
+ */
+export function isLeaderboardScore(gameId, score) {
+    const scores = getHighScores(gameId);
+    if (scores.length < MAX_SCORES_PER_GAME) {
+        return true;
+    }
+    const lowestScore = scores[scores.length - 1].score;
+    return score > lowestScore;
+}
+/**
+ * Check if a score beats the current high score (#1)
+ * This is the "NEW HIGH SCORE!" condition for coin award
+ */
+export function isNewHighScore(gameId, score) {
+    const scores = getHighScores(gameId);
+    if (scores.length === 0) {
+        return true; // First score is always a high score
+    }
+    return score > scores[0].score; // Must beat #1
+}
+/**
+ * Check if a score qualifies for the leaderboard
+ * @deprecated Use isLeaderboardScore for top-10 check, isNewHighScore for #1 check
+ */
+export function isHighScore(gameId, score) {
+    return isLeaderboardScore(gameId, score);
+}
+/**
+ * Get the rank a score would achieve (1-based, or null if not a high score)
+ */
+export function getScoreRank(gameId, score) {
+    const scores = getHighScores(gameId);
+    // Find where this score would be inserted
+    let rank = 1;
+    for (const existing of scores) {
+        if (score > existing.score) {
+            break;
+        }
+        rank++;
+    }
+    // Check if it makes the leaderboard
+    if (rank > MAX_SCORES_PER_GAME) {
+        return null;
+    }
+    return rank;
+}
+/**
+ * Add a new high score
+ * Returns the rank achieved (1-based) or null if didn't make the leaderboard
+ */
+export function addHighScore(gameId, name, score, level) {
+    const data = getScoresData();
+    const partialData = data;
+    const scores = partialData[gameId] ?? [];
+    const newScore = {
+        name: name.toUpperCase().slice(0, 3).padEnd(3, ' '),
+        score,
+        level,
+        date: new Date().toISOString().split('T')[0],
+    };
+    // Insert in sorted order (descending by score)
+    let insertIndex = 0;
+    for (let i = 0; i < scores.length; i++) {
+        if (score > scores[i].score) {
+            break;
+        }
+        insertIndex++;
+    }
+    scores.splice(insertIndex, 0, newScore);
+    // Keep only top scores
+    if (scores.length > MAX_SCORES_PER_GAME) {
+        scores.length = MAX_SCORES_PER_GAME;
+    }
+    data[gameId] = scores;
+    scoresCache = data;
+    saveToDisk(data);
+    // Return rank if made the leaderboard
+    if (insertIndex < MAX_SCORES_PER_GAME) {
+        return insertIndex + 1;
+    }
+    return null;
+}
+/**
+ * Get the player's best score for a game
+ */
+export function getBestScore(gameId) {
+    const scores = getHighScores(gameId);
+    return scores.length > 0 ? scores[0] : null;
+}
+/**
+ * Clear high scores for a game (for testing)
+ */
+export function clearHighScores(gameId) {
+    const data = getScoresData();
+    // Create a new object without the specified gameId
+    const { [gameId]: _removed, ...rest } = data;
+    scoresCache = rest;
+    saveToDisk(rest);
+}
+/**
+ * Clear all high scores (for testing)
+ */
+export function clearAllHighScores() {
+    scoresCache = {};
+    saveToDisk({});
+}
+/**
+ * Clear cache (for testing)
+ */
+export function clearScoresCache() {
+    scoresCache = null;
+}
+/**
+ * Format a score number with commas
+ */
+export function formatScore(score) {
+    return score.toLocaleString();
+}
+/**
+ * Format a high score entry for display
+ */
+export function formatHighScoreEntry(rank, entry, maxScoreWidth = 10) {
+    const rankStr = String(rank).padStart(2, ' ');
+    const scoreStr = formatScore(entry.score).padStart(maxScoreWidth, '.');
+    const levelStr = `Lv.${String(entry.level).padStart(2, ' ')}`;
+    return `${rankStr}. ${entry.name} ${scoreStr}  ${levelStr}  ${entry.date}`;
+}

package/dist/games/tetris/board.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Tetris Board
+ *
+ * Game board logic - collision detection, line clearing, etc.
+ */
+import type { Piece } from './pieces.js';
+export declare const BOARD_WIDTH = 10;
+export declare const BOARD_HEIGHT = 20;
+export declare const HIDDEN_ROWS = 2;
+export interface Position {
+    x: number;
+    y: number;
+}
+export type Board = number[][];
+/**
+ * Create an empty board
+ */
+export declare function createBoard(): Board;
+/**
+ * Check if a position is within bounds
+ */
+export declare function isInBounds(x: number, y: number): boolean;
+/**
+ * Check if a piece can be placed at a position
+ */
+export declare function canPlace(board: Board, piece: Piece, position: Position): boolean;
+/**
+ * Place a piece on the board (mutates board)
+ */
+export declare function placePiece(board: Board, piece: Piece, position: Position): void;
+/**
+ * Check for and clear completed lines
+ * Returns the number of lines cleared
+ */
+export declare function clearLines(board: Board): number;
+/**
+ * Get the spawn position for a new piece
+ */
+export declare function getSpawnPosition(piece: Piece): Position;
+/**
+ * Get the ghost piece position (where piece would land)
+ */
+export declare function getGhostPosition(board: Board, piece: Piece, position: Position): Position;
+/**
+ * Check if the game is over (piece can't spawn)
+ */
+export declare function isGameOver(board: Board, piece: Piece): boolean;
+/**
+ * Calculate drop distance for hard drop scoring
+ */
+export declare function getDropDistance(board: Board, piece: Piece, position: Position): number;
+/**
+ * Clone a board (for preview/undo)
+ */
+export declare function cloneBoard(board: Board): Board;
+/**
+ * Get the board with current piece overlaid (for rendering)
+ */
+export declare function getBoardWithPiece(board: Board, piece: Piece | null, position: Position | null, showGhost?: boolean): Board;