readr-cli 1.0.0

package/dist/display.d.ts

@@ -0,0 +1,12 @@
+import { Book, Session } from './types.js';
+export declare function progressBar(current: number, total: number, width?: number): string;
+export declare function formatDuration(ms: number): string;
+export declare function getBookStats(book: Book, sessions: Session[]): {
+    totalMs: number;
+    totalPagesRead: number;
+    pagesPerHour: number;
+    etaMs: number | null;
+    sessionCount: number;
+};
+export declare function printBookCard(book: Book, sessions: Session[], activeSessionId?: string): void;
+export declare function printSessionSummary(session: Session, book: Book): void;

package/dist/display.js

@@ -0,0 +1,74 @@
+import chalk from 'chalk';
+export function progressBar(current, total, width = 30) {
+    const pct = Math.min(current / total, 1);
+    const filled = Math.round(pct * width);
+    const empty = width - filled;
+    const bar = chalk.green('█'.repeat(filled)) + chalk.gray('░'.repeat(empty));
+    return `[${bar}] ${chalk.bold((pct * 100).toFixed(1))}%`;
+}
+export function formatDuration(ms) {
+    const totalSec = Math.floor(ms / 1000);
+    const h = Math.floor(totalSec / 3600);
+    const m = Math.floor((totalSec % 3600) / 60);
+    const s = totalSec % 60;
+    if (h > 0)
+        return `${h}h ${m}m`;
+    if (m > 0)
+        return `${m}m ${s}s`;
+    return `${s}s`;
+}
+export function getBookStats(book, sessions) {
+    const bookSessions = sessions.filter((s) => s.bookId === book.id && s.status === 'completed');
+    const totalMs = bookSessions.reduce((acc, s) => {
+        if (!s.endTime)
+            return acc;
+        const raw = new Date(s.endTime).getTime() - new Date(s.startTime).getTime();
+        return acc + raw - s.totalPausedMs;
+    }, 0);
+    const totalPagesRead = bookSessions.reduce((acc, s) => {
+        return acc + ((s.endPage ?? s.startPage) - s.startPage);
+    }, 0);
+    const pagesPerHour = totalMs > 0 ? (totalPagesRead / totalMs) * 3600000 : 0;
+    const pagesLeft = book.totalPages - book.currentPage;
+    const etaMs = pagesPerHour > 0 ? (pagesLeft / pagesPerHour) * 3600000 : null;
+    return { totalMs, totalPagesRead, pagesPerHour, etaMs, sessionCount: bookSessions.length };
+}
+export function printBookCard(book, sessions, activeSessionId) {
+    const stats = getBookStats(book, sessions);
+    const isActive = sessions.find((s) => s.bookId === book.id && (s.status === 'active' || s.status === 'paused'));
+    console.log('');
+    console.log(chalk.bold.cyan(`📖 ${book.title}`) + chalk.gray(` by ${book.author}`));
+    console.log(`   ${progressBar(book.currentPage, book.totalPages)}`);
+    console.log(`   ${chalk.yellow('Page:')} ${chalk.bold(book.currentPage)} / ${book.totalPages}  ` +
+        `${chalk.yellow('Sessions:')} ${stats.sessionCount}  ` +
+        `${chalk.yellow('Time:')} ${formatDuration(stats.totalMs)}`);
+    if (stats.pagesPerHour > 0) {
+        console.log(`   ${chalk.yellow('Speed:')} ${stats.pagesPerHour.toFixed(1)} pages/hr  ` +
+            (stats.etaMs !== null
+                ? `${chalk.yellow('ETA:')} ${chalk.bold.green(formatDuration(stats.etaMs))} left`
+                : ''));
+    }
+    else {
+        console.log(`   ${chalk.gray('No speed data yet — start a session!')}`);
+    }
+    if (isActive) {
+        const status = isActive.status === 'paused' ? chalk.yellow('⏸  PAUSED') : chalk.green('▶  READING');
+        console.log(`   ${status} ${chalk.gray(`from page ${isActive.startPage}`)}`);
+    }
+    console.log('');
+}
+export function printSessionSummary(session, book) {
+    const pagesRead = (session.endPage ?? session.startPage) - session.startPage;
+    const rawMs = new Date(session.endTime).getTime() - new Date(session.startTime).getTime();
+    const activeMs = rawMs - session.totalPausedMs;
+    const speed = activeMs > 0 ? (pagesRead / activeMs) * 3600000 : 0;
+    console.log('');
+    console.log(chalk.bold.green('✅  Session complete!'));
+    console.log(chalk.gray('─'.repeat(40)));
+    console.log(`  ${chalk.yellow('Book:')}       ${book.title}`);
+    console.log(`  ${chalk.yellow('Pages:')}      ${session.startPage} → ${session.endPage}  ${chalk.bold('(+' + pagesRead + ')')}`);
+    console.log(`  ${chalk.yellow('Duration:')}   ${formatDuration(activeMs)}`);
+    console.log(`  ${chalk.yellow('Speed:')}      ${speed.toFixed(1)} pages/hr`);
+    console.log(chalk.gray('─'.repeat(40)));
+    console.log('');
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import readline from 'readline';
+import chalk from 'chalk';
+import { loadStore, saveStore, generateId } from './store.js';
+import { printBookCard, printSessionSummary, progressBar, formatDuration, getBookStats } from './display.js';
+const args = process.argv.slice(2);
+const command = args[0];
+function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (ans) => { rl.close(); resolve(ans.trim()); });
+    });
+}
+function header() {
+    console.log('');
+    console.log(chalk.bold.magenta('  📚 Reading Tracker'));
+    console.log(chalk.gray('  ─────────────────────────────────'));
+}
+async function addBook() {
+    header();
+    const title = await prompt(chalk.cyan('  Book title: '));
+    const author = await prompt(chalk.cyan('  Author: '));
+    const totalPagesStr = await prompt(chalk.cyan('  Total pages: '));
+    const currentPageStr = await prompt(chalk.cyan('  Current page (0 if new): '));
+    const totalPages = parseInt(totalPagesStr);
+    const currentPage = parseInt(currentPageStr) || 0;
+    if (!title || isNaN(totalPages)) {
+        console.log(chalk.red('  ✗ Invalid input.'));
+        process.exit(1);
+    }
+    const store = loadStore();
+    const book = {
+        id: generateId(),
+        title,
+        author,
+        totalPages,
+        currentPage,
+        addedAt: new Date().toISOString(),
+    };
+    store.books.push(book);
+    saveStore(store);
+    console.log(chalk.green(`\n  ✓ Added "${title}"!`));
+    printBookCard(book, []);
+}
+async function startSession() {
+    const store = loadStore();
+    const existing = store.sessions.find((s) => s.status === 'active' || s.status === 'paused');
+    if (existing) {
+        const book = store.books.find((b) => b.id === existing.bookId);
+        console.log(chalk.yellow(`\n  ⚠ You already have a session for "${book.title}" (${existing.status})`));
+        console.log(chalk.gray('  Use: read pause | read stop\n'));
+        process.exit(1);
+    }
+    if (store.books.length === 0) {
+        console.log(chalk.red('\n  No books found. Add one with: read add\n'));
+        process.exit(1);
+    }
+    header();
+    console.log(chalk.bold('  Your books:\n'));
+    store.books.forEach((b, i) => {
+        console.log(`  ${chalk.bold.cyan(i + 1 + '.')} ${b.title} ${chalk.gray(`— page ${b.currentPage}/${b.totalPages}`)}`);
+    });
+    const choiceStr = await prompt(chalk.cyan('\n  Pick a book (number): '));
+    const choice = parseInt(choiceStr) - 1;
+    const book = store.books[choice];
+    if (!book) {
+        console.log(chalk.red('  ✗ Invalid choice.'));
+        process.exit(1);
+    }
+    const startPageStr = await prompt(chalk.cyan(`  Starting from page (enter for ${book.currentPage}): `));
+    const startPage = parseInt(startPageStr) || book.currentPage;
+    const session = {
+        id: generateId(),
+        bookId: book.id,
+        startPage,
+        startTime: new Date().toISOString(),
+        totalPausedMs: 0,
+        status: 'active',
+    };
+    store.sessions.push(session);
+    store.activeSessionId = session.id;
+    saveStore(store);
+    console.log('');
+    console.log(chalk.green(`  ▶  Session started for "${book.title}"`));
+    console.log(chalk.gray(`     From page ${startPage} — happy reading! 📖`));
+    console.log('');
+}
+function pauseSession() {
+    const store = loadStore();
+    const session = store.sessions.find((s) => s.status === 'active' || s.status === 'paused');
+    if (!session) {
+        console.log(chalk.red('\n  No active session. Start one with: read start\n'));
+        process.exit(1);
+    }
+    const book = store.books.find((b) => b.id === session.bookId);
+    if (session.status === 'paused') {
+        const pausedMs = new Date().getTime() - new Date(session.pausedAt).getTime();
+        session.totalPausedMs += pausedMs;
+        session.pausedAt = undefined;
+        session.status = 'active';
+        saveStore(store);
+        console.log(chalk.green(`\n  ▶  Resumed "${book.title}"\n`));
+    }
+    else {
+        session.pausedAt = new Date().toISOString();
+        session.status = 'paused';
+        saveStore(store);
+        const elapsed = new Date().getTime() - new Date(session.startTime).getTime() - session.totalPausedMs;
+        console.log(chalk.yellow(`\n  ⏸  Paused "${book.title}" — ${formatDuration(elapsed)} so far\n`));
+    }
+}
+async function stopSession() {
+    const store = loadStore();
+    const session = store.sessions.find((s) => s.status === 'active' || s.status === 'paused');
+    if (!session) {
+        console.log(chalk.red('\n  No active session. Start one with: read start\n'));
+        process.exit(1);
+    }
+    const book = store.books.find((b) => b.id === session.bookId);
+    const endPageStr = await prompt(chalk.cyan(`\n  Ending on page (enter for current ${book.currentPage}): `));
+    const endPage = parseInt(endPageStr) || book.currentPage;
+    if (session.status === 'paused' && session.pausedAt) {
+        session.totalPausedMs += new Date().getTime() - new Date(session.pausedAt).getTime();
+    }
+    session.endPage = endPage;
+    session.endTime = new Date().toISOString();
+    session.status = 'completed';
+    delete store.activeSessionId;
+    book.currentPage = endPage;
+    saveStore(store);
+    printSessionSummary(session, book);
+    printBookCard(book, store.sessions);
+}
+function listBooks() {
+    const store = loadStore();
+    if (store.books.length === 0) {
+        console.log(chalk.gray('\n  No books yet. Add one with: read add\n'));
+        return;
+    }
+    header();
+    for (const book of store.books) {
+        printBookCard(book, store.sessions, store.activeSessionId);
+    }
+}
+function showStats() {
+    const store = loadStore();
+    if (store.books.length === 0) {
+        console.log(chalk.gray('\n  No books yet. Add one with: read add\n'));
+        return;
+    }
+    header();
+    console.log(chalk.bold('  📊 Overall Stats\n'));
+    const completedSessions = store.sessions.filter((s) => s.status === 'completed');
+    const totalMs = completedSessions.reduce((acc, s) => {
+        if (!s.endTime)
+            return acc;
+        return acc + (new Date(s.endTime).getTime() - new Date(s.startTime).getTime() - s.totalPausedMs);
+    }, 0);
+    const totalPages = completedSessions.reduce((acc, s) => {
+        return acc + ((s.endPage ?? s.startPage) - s.startPage);
+    }, 0);
+    console.log(`  ${chalk.yellow('Total reading time:')}  ${chalk.bold(formatDuration(totalMs))}`);
+    console.log(`  ${chalk.yellow('Total pages read:')}   ${chalk.bold(totalPages)}`);
+    console.log(`  ${chalk.yellow('Total sessions:')}     ${chalk.bold(completedSessions.length)}`);
+    console.log('');
+    for (const book of store.books) {
+        const stats = getBookStats(book, store.sessions);
+        console.log(`  ${chalk.bold.cyan(book.title)}`);
+        console.log(`  ${progressBar(book.currentPage, book.totalPages, 25)}`);
+        if (stats.pagesPerHour > 0) {
+            console.log(`  ${chalk.gray(`${book.currentPage}/${book.totalPages} pages · ${stats.pagesPerHour.toFixed(1)} pg/hr · ETA: ${stats.etaMs !== null ? formatDuration(stats.etaMs) : '?'}`)}`);
+        }
+        console.log('');
+    }
+}
+function showHelp() {
+    header();
+    console.log(chalk.bold('  Commands:\n'));
+    const cmds = [
+        ['read add', 'Add a new book'],
+        ['read start', 'Start a reading session'],
+        ['read pause', 'Pause or resume current session'],
+        ['read stop', 'End session & log pages read'],
+        ['read list', 'List all books with progress'],
+        ['read stats', 'Overall reading statistics'],
+        ['read help', 'Show this help'],
+    ];
+    for (const [cmd, desc] of cmds) {
+        console.log(`  ${chalk.bold.green(cmd.padEnd(14))} ${chalk.gray(desc)}`);
+    }
+    console.log('');
+}
+(async () => {
+    switch (command) {
+        case 'add':
+            await addBook();
+            break;
+        case 'start':
+            await startSession();
+            break;
+        case 'pause':
+            pauseSession();
+            break;
+        case 'stop':
+            await stopSession();
+            break;
+        case 'list':
+            listBooks();
+            break;
+        case 'stats':
+            showStats();
+            break;
+        case 'help':
+        default:
+            showHelp();
+            break;
+    }
+})();

package/dist/store.d.ts

@@ -0,0 +1,4 @@
+import { Store } from './types.js';
+export declare function loadStore(): Store;
+export declare function saveStore(store: Store): void;
+export declare function generateId(): string;

package/dist/store.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const STORE_PATH = path.join(os.homedir(), '.reading-cli', 'data.json');
+const DEFAULT_STORE = {
+    books: [],
+    sessions: [],
+};
+export function loadStore() {
+    try {
+        if (!fs.existsSync(STORE_PATH)) {
+            fs.mkdirSync(path.dirname(STORE_PATH), { recursive: true });
+            fs.writeFileSync(STORE_PATH, JSON.stringify(DEFAULT_STORE, null, 2));
+            return DEFAULT_STORE;
+        }
+        return JSON.parse(fs.readFileSync(STORE_PATH, 'utf-8'));
+    }
+    catch {
+        return { ...DEFAULT_STORE };
+    }
+}
+export function saveStore(store) {
+    fs.mkdirSync(path.dirname(STORE_PATH), { recursive: true });
+    fs.writeFileSync(STORE_PATH, JSON.stringify(store, null, 2));
+}
+export function generateId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
+}

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+export interface Book {
+    id: string;
+    title: string;
+    author: string;
+    totalPages: number;
+    currentPage: number;
+    addedAt: string;
+    finishedAt?: string;
+}
+export interface Session {
+    id: string;
+    bookId: string;
+    startPage: number;
+    endPage?: number;
+    startTime: string;
+    endTime?: string;
+    pausedAt?: string;
+    totalPausedMs: number;
+    status: 'active' | 'paused' | 'completed';
+}
+export interface Store {
+    books: Book[];
+    sessions: Session[];
+    activeSessionId?: string;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "readr-cli",
+  "version": "1.0.0",
+  "description": "Beautiful CLI to track reading sessions, speed, and book completion ETA",
+  "type": "module",
+  "bin": {
+    "reading": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": ["reading", "tracker", "cli", "books", "progress"],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.4",
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3"
+  }
+}