@compilr-dev/cli 0.5.0 → 0.5.2

package/dist/episodes/work-summary-anchor.js

@@ -0,0 +1,73 @@
+/**
+ * Work Summary Anchor
+ *
+ * Manages an auto-generated anchor that summarizes work done in the current session.
+ * Updated automatically after each episode batch is flushed.
+ */
+const ANCHOR_TAG = 'episode-work-summary';
+/**
+ * Build the anchor content string from the store's work summary.
+ * Returns null when there are no episodes to summarize.
+ */
+export function buildWorkSummaryContent(summary) {
+    if (summary.episodeCount === 0)
+        return null;
+    const lines = ['[Session Work Summary]'];
+    lines.push(`Episodes: ${String(summary.episodeCount)}, Effort: ${summary.totalEffort}, Time: ${formatMs(summary.timeSpentMs)}`);
+    if (summary.agentBreakdown.length > 0) {
+        const agents = summary.agentBreakdown
+            .map(a => `${a.agentId}(${String(a.episodeCount)})`)
+            .join(', ');
+        lines.push(`Agents: ${agents}`);
+    }
+    if (summary.topFiles.length > 0) {
+        const files = summary.topFiles.slice(0, 5)
+            .map(f => f.path.split('/').pop() ?? f.path)
+            .join(', ');
+        lines.push(`Top files: ${files}`);
+    }
+    if (summary.uncommittedWork.length > 0) {
+        lines.push(`Uncommitted: ${String(summary.uncommittedWork.length)} episode(s)`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Update the work summary anchor for a project.
+ * Removes existing anchor (if any) and adds updated one.
+ */
+export function updateWorkSummaryAnchor(config) {
+    const { store, projectId, getAnchorManager: getManager } = config;
+    const manager = getManager(projectId);
+    const summary = store.getWorkSummary();
+    const content = buildWorkSummaryContent(summary);
+    // Remove existing work summary anchor
+    const existing = manager.getAll().find((a) => a.tags?.includes(ANCHOR_TAG));
+    if (existing)
+        manager.remove(existing.id);
+    // Add new anchor if there's content
+    if (content) {
+        manager.add({
+            content,
+            priority: 'info',
+            scope: 'persistent',
+            tags: [ANCHOR_TAG],
+            projectId,
+        });
+    }
+}
+/**
+ * Format milliseconds to a human-readable string (e.g., "2h 15m", "45s").
+ */
+function formatMs(ms) {
+    if (ms < 1000)
+        return `${String(ms)}ms`;
+    const totalSeconds = Math.floor(ms / 1000);
+    if (totalSeconds < 60)
+        return `${String(totalSeconds)}s`;
+    const minutes = Math.floor(totalSeconds / 60);
+    if (minutes < 60)
+        return `${String(minutes)}m`;
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${String(hours)}h ${String(remainingMinutes)}m` : `${String(hours)}h`;
+}

package/dist/games/coins.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Coin System
+ *
+ * Manages arcade coins for the games easter egg.
+ * Coins are earned through productive CLI usage and spent to play games.
+ */
+export interface CoinData {
+    coins: number;
+    totalEarned: number;
+    totalSpent: number;
+    lastDailyBonus: string | null;
+}
+export declare const COIN_COST_START_GAME = 1;
+export declare const COIN_COST_CONTINUE = 2;
+export declare const COIN_REWARD_WORK_ITEM = 1;
+export declare const COIN_REWARD_FIRST_PROJECT = 3;
+export declare const COIN_REWARD_DAILY_BONUS = 1;
+export declare const COIN_REWARD_HIGH_SCORE = 2;
+/**
+ * Get current coin data
+ */
+export declare function getCoinData(): CoinData;
+/**
+ * Get current coin balance
+ */
+export declare function getCoins(): number;
+/**
+ * Check if player has enough coins
+ */
+export declare function hasCoins(amount: number): boolean;
+/**
+ * Spend coins (returns true if successful)
+ */
+export declare function spendCoins(amount: number): boolean;
+/**
+ * Earn coins
+ */
+export declare function earnCoins(amount: number, reason?: string): void;
+/**
+ * Check and award daily bonus if eligible
+ */
+export declare function checkDailyBonus(): boolean;
+/**
+ * Award coins for completing a work item
+ */
+export declare function awardWorkItemCompletion(): void;
+/**
+ * Award coins for creating first project
+ */
+export declare function awardFirstProject(): void;
+/**
+ * Award coins for achieving a high score
+ */
+export declare function awardHighScore(): void;
+/**
+ * Clear cache (for testing)
+ */
+export declare function clearCoinCache(): void;
+/**
+ * Format coins for display (e.g., "●●●○○" for 3/5)
+ */
+export declare function formatCoinsDisplay(current: number, max?: number): string;
+/**
+ * Get a short coin display string
+ */
+export declare function getCoinsDisplayShort(): string;

package/dist/games/coins.js

@@ -0,0 +1,165 @@
+/**
+ * Coin System
+ *
+ * Manages arcade coins for the games easter egg.
+ * Coins are earned through productive CLI usage and spent to play 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 GAMES_FILE = path.join(CONFIG_DIR, 'games.json');
+const DEFAULT_COIN_DATA = {
+    coins: 3, // Start with 3 free coins!
+    totalEarned: 3,
+    totalSpent: 0,
+    lastDailyBonus: null,
+};
+// Coin costs
+export const COIN_COST_START_GAME = 1;
+export const COIN_COST_CONTINUE = 2;
+// Coin rewards
+export const COIN_REWARD_WORK_ITEM = 1;
+export const COIN_REWARD_FIRST_PROJECT = 3;
+export const COIN_REWARD_DAILY_BONUS = 1;
+export const COIN_REWARD_HIGH_SCORE = 2;
+// =============================================================================
+// In-memory cache
+// =============================================================================
+let coinCache = null;
+// =============================================================================
+// Persistence
+// =============================================================================
+function loadFromDisk() {
+    try {
+        if (fs.existsSync(GAMES_FILE)) {
+            const data = fs.readFileSync(GAMES_FILE, 'utf-8');
+            const parsed = JSON.parse(data);
+            return { ...DEFAULT_COIN_DATA, ...parsed };
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return { ...DEFAULT_COIN_DATA };
+}
+function saveToDisk(data) {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(GAMES_FILE, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to save coin data:', error);
+    }
+}
+// =============================================================================
+// Public API
+// =============================================================================
+/**
+ * Get current coin data
+ */
+export function getCoinData() {
+    if (coinCache) {
+        return coinCache;
+    }
+    coinCache = loadFromDisk();
+    return coinCache;
+}
+/**
+ * Get current coin balance
+ */
+export function getCoins() {
+    return getCoinData().coins;
+}
+/**
+ * Check if player has enough coins
+ */
+export function hasCoins(amount) {
+    return getCoins() >= amount;
+}
+/**
+ * Spend coins (returns true if successful)
+ */
+export function spendCoins(amount) {
+    const data = getCoinData();
+    if (data.coins < amount) {
+        return false;
+    }
+    data.coins -= amount;
+    data.totalSpent += amount;
+    coinCache = data;
+    saveToDisk(data);
+    return true;
+}
+/**
+ * Earn coins
+ */
+export function earnCoins(amount, reason) {
+    const data = getCoinData();
+    data.coins += amount;
+    data.totalEarned += amount;
+    coinCache = data;
+    saveToDisk(data);
+    // Log for debugging (could be made optional)
+    if (reason) {
+        // Silent for now - could add notification later
+    }
+}
+/**
+ * Check and award daily bonus if eligible
+ */
+export function checkDailyBonus() {
+    const data = getCoinData();
+    const today = new Date().toISOString().split('T')[0];
+    if (data.lastDailyBonus !== today) {
+        data.lastDailyBonus = today;
+        data.coins += COIN_REWARD_DAILY_BONUS;
+        data.totalEarned += COIN_REWARD_DAILY_BONUS;
+        coinCache = data;
+        saveToDisk(data);
+        return true;
+    }
+    return false;
+}
+/**
+ * Award coins for completing a work item
+ */
+export function awardWorkItemCompletion() {
+    earnCoins(COIN_REWARD_WORK_ITEM, 'work_item_completed');
+}
+/**
+ * Award coins for creating first project
+ */
+export function awardFirstProject() {
+    earnCoins(COIN_REWARD_FIRST_PROJECT, 'first_project');
+}
+/**
+ * Award coins for achieving a high score
+ */
+export function awardHighScore() {
+    earnCoins(COIN_REWARD_HIGH_SCORE, 'high_score');
+}
+/**
+ * Clear cache (for testing)
+ */
+export function clearCoinCache() {
+    coinCache = null;
+}
+/**
+ * Format coins for display (e.g., "●●●○○" for 3/5)
+ */
+export function formatCoinsDisplay(current, max = 10) {
+    const filled = Math.min(current, max);
+    const empty = Math.max(0, max - filled);
+    return '●'.repeat(filled) + '○'.repeat(empty);
+}
+/**
+ * Get a short coin display string
+ */
+export function getCoinsDisplayShort() {
+    const coins = getCoins();
+    return `${String(coins)} coin${coins !== 1 ? 's' : ''}`;
+}

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
+            },
+        },
+    ];
+}