rv-bible-cli 0.1.0

package/dist/parser.js

@@ -0,0 +1,320 @@
+// Bible reference parser
+// Converts user input like "john 3:16-18" → structured ParsedRef
+// Maps lowercased user input → canonical DB abbreviation
+const ALIASES = {
+    // Genesis
+    gen: 'Gen', genesis: 'Gen',
+    // Exodus
+    exo: 'Exo', ex: 'Exo', exod: 'Exo', exodus: 'Exo',
+    // Leviticus
+    lev: 'Lev', leviticus: 'Lev',
+    // Numbers
+    num: 'Num', numb: 'Num', numbers: 'Num',
+    // Deuteronomy
+    deu: 'Deu', deut: 'Deu', dt: 'Deu', deuteronomy: 'Deu',
+    // Joshua
+    jos: 'Jos', josh: 'Jos', joshua: 'Jos',
+    // Judges
+    jdg: 'Jdg', judg: 'Jdg', judges: 'Jdg',
+    // Ruth
+    rut: 'Rut', ruth: 'Rut',
+    // 1 Samuel
+    '1sa': '1Sa', '1sam': '1Sa', '1samuel': '1Sa', '1 sam': '1Sa', '1 samuel': '1Sa',
+    // 2 Samuel
+    '2sa': '2Sa', '2sam': '2Sa', '2samuel': '2Sa', '2 sam': '2Sa', '2 samuel': '2Sa',
+    // 1 Kings
+    '1ki': '1Ki', '1kgs': '1Ki', '1kings': '1Ki', '1 kings': '1Ki', '1 kgs': '1Ki',
+    // 2 Kings
+    '2ki': '2Ki', '2kgs': '2Ki', '2kings': '2Ki', '2 kings': '2Ki', '2 kgs': '2Ki',
+    // 1 Chronicles
+    '1ch': '1Ch', '1chr': '1Ch', '1chron': '1Ch', '1chronicles': '1Ch', '1 chr': '1Ch', '1 chronicles': '1Ch',
+    // 2 Chronicles
+    '2ch': '2Ch', '2chr': '2Ch', '2chron': '2Ch', '2chronicles': '2Ch', '2 chr': '2Ch', '2 chronicles': '2Ch',
+    // Ezra
+    ezr: 'Ezr', ezra: 'Ezr',
+    // Nehemiah
+    neh: 'Neh', nehemiah: 'Neh',
+    // Esther
+    est: 'Est', esther: 'Est',
+    // Job
+    job: 'Job',
+    // Psalms
+    psa: 'Psa', ps: 'Psa', psalm: 'Psa', psalms: 'Psa',
+    // Proverbs
+    prv: 'Prv', prov: 'Prv', proverbs: 'Prv',
+    // Ecclesiastes
+    ecc: 'Ecc', eccl: 'Ecc', ecclesiastes: 'Ecc', qoh: 'Ecc',
+    // Song of Songs
+    sos: 'SoS', ss: 'SoS', sg: 'SoS', cant: 'SoS', canticles: 'SoS',
+    song: 'SoS', 'song of songs': 'SoS', 'song of solomon': 'SoS', 'songs': 'SoS',
+    // Isaiah
+    isa: 'Isa', isaiah: 'Isa',
+    // Jeremiah
+    jer: 'Jer', jeremiah: 'Jer',
+    // Lamentations
+    lam: 'Lam', lamentations: 'Lam',
+    // Ezekiel
+    ezk: 'Ezk', ezek: 'Ezk', ezekiel: 'Ezk',
+    // Daniel
+    dan: 'Dan', daniel: 'Dan',
+    // Hosea
+    hos: 'Hos', hosea: 'Hos',
+    // Joel
+    joe: 'Joe', joel: 'Joe',
+    // Amos
+    amo: 'Amo', amos: 'Amo',
+    // Obadiah
+    oba: 'Oba', obad: 'Oba', obadiah: 'Oba',
+    // Jonah
+    jon: 'Jon', jonah: 'Jon',
+    // Micah
+    mic: 'Mic', micah: 'Mic',
+    // Nahum
+    nah: 'Nah', nahum: 'Nah',
+    // Habakkuk
+    hab: 'Hab', habakkuk: 'Hab',
+    // Zephaniah
+    zep: 'Zep', zeph: 'Zep', zephaniah: 'Zep',
+    // Haggai
+    hag: 'Hag', haggai: 'Hag',
+    // Zechariah
+    zec: 'Zec', zech: 'Zec', zechariah: 'Zec',
+    // Malachi
+    mal: 'Mal', malachi: 'Mal',
+    // Matthew
+    mat: 'Mat', matt: 'Mat', mt: 'Mat', matthew: 'Mat',
+    // Mark
+    mrk: 'Mrk', mar: 'Mrk', mk: 'Mrk', mark: 'Mrk',
+    // Luke
+    luk: 'Luk', lk: 'Luk', luke: 'Luk',
+    // John
+    joh: 'Joh', jn: 'Joh', john: 'Joh',
+    // Acts
+    act: 'Act', ac: 'Act', acts: 'Act',
+    // Romans
+    rom: 'Rom', rm: 'Rom', romans: 'Rom',
+    // 1 Corinthians
+    '1co': '1Co', '1cor': '1Co', '1corinthians': '1Co', '1 cor': '1Co', '1 corinthians': '1Co',
+    // 2 Corinthians
+    '2co': '2Co', '2cor': '2Co', '2corinthians': '2Co', '2 cor': '2Co', '2 corinthians': '2Co',
+    // Galatians
+    gal: 'Gal', galatians: 'Gal',
+    // Ephesians
+    eph: 'Eph', ephesians: 'Eph',
+    // Philippians
+    phi: 'Phi', phil: 'Phi', php: 'Phi', philippians: 'Phi',
+    // Colossians
+    col: 'Col', colossians: 'Col',
+    // 1 Thessalonians
+    '1th': '1Th', '1thes': '1Th', '1thess': '1Th', '1thessalonians': '1Th',
+    '1 thes': '1Th', '1 thess': '1Th', '1 thessalonians': '1Th',
+    // 2 Thessalonians
+    '2th': '2Th', '2thes': '2Th', '2thess': '2Th', '2thessalonians': '2Th',
+    '2 thes': '2Th', '2 thess': '2Th', '2 thessalonians': '2Th',
+    // 1 Timothy
+    '1ti': '1Ti', '1tim': '1Ti', '1timothy': '1Ti', '1 tim': '1Ti', '1 timothy': '1Ti',
+    // 2 Timothy
+    '2ti': '2Ti', '2tim': '2Ti', '2timothy': '2Ti', '2 tim': '2Ti', '2 timothy': '2Ti',
+    // Titus
+    tit: 'Tit', titus: 'Tit',
+    // Philemon
+    phm: 'Phm', phile: 'Phm', philemon: 'Phm',
+    // Hebrews
+    heb: 'Heb', hebrews: 'Heb',
+    // James
+    jam: 'Jam', jas: 'Jam', james: 'Jam',
+    // 1 Peter
+    '1pe': '1Pe', '1pet': '1Pe', '1peter': '1Pe', '1 pet': '1Pe', '1 peter': '1Pe',
+    // 2 Peter
+    '2pe': '2Pe', '2pet': '2Pe', '2peter': '2Pe', '2 pet': '2Pe', '2 peter': '2Pe',
+    // 1 John
+    '1jo': '1Jo', '1jn': '1Jo', '1john': '1Jo', '1 jn': '1Jo', '1 john': '1Jo',
+    // 2 John
+    '2jo': '2Jo', '2jn': '2Jo', '2john': '2Jo', '2 jn': '2Jo', '2 john': '2Jo',
+    // 3 John
+    '3jo': '3Jo', '3jn': '3Jo', '3john': '3Jo', '3 jn': '3Jo', '3 john': '3Jo',
+    // Jude
+    jud: 'Jud', jude: 'Jud',
+    // Revelation
+    rev: 'Rev', revelation: 'Rev', revelations: 'Rev',
+};
+// Resolve a user-typed book name to a canonical abbreviation.
+// Tries exact match, then prefix match on known aliases.
+export function resolveBook(input) {
+    const normalized = input.toLowerCase().trim().replace(/\.+$/, '');
+    if (ALIASES[normalized])
+        return ALIASES[normalized];
+    // Prefix match: "gen" matches "genesis", "phil" matches "philippians"
+    // but be careful not to match "ph" → both Phi and Phm
+    const prefixMatches = Object.keys(ALIASES).filter(k => k.startsWith(normalized));
+    if (prefixMatches.length === 1)
+        return ALIASES[prefixMatches[0]];
+    // If multiple prefix matches, only accept if they all resolve to the same book
+    if (prefixMatches.length > 1) {
+        const targets = [...new Set(prefixMatches.map(k => ALIASES[k]))];
+        if (targets.length === 1)
+            return targets[0];
+    }
+    return null;
+}
+// Parse the verse portion of a reference (after "chapter:")
+function parseVerseSpec(verseStr) {
+    if (verseStr.includes(',')) {
+        return { type: 'list', verses: verseStr.split(',').map(v => v.trim()) };
+    }
+    if (verseStr.includes('-')) {
+        const dashIdx = verseStr.indexOf('-');
+        return {
+            type: 'range',
+            start: verseStr.slice(0, dashIdx).trim(),
+            end: verseStr.slice(dashIdx + 1).trim(),
+        };
+    }
+    return { type: 'single', verse: verseStr.trim() };
+}
+// Parse a single Bible reference string into a structured object.
+// Input is a joined string e.g. "john 3", "john 3:16", "john 3:16-18", "1co 13:4,7"
+export function parseRef(input) {
+    const trimmed = input.trim();
+    // Split book name from chapter[:verse] at the end.
+    // The chapter:verse part always starts with a digit.
+    // We greedily consume from the right: last token starting with a digit is the ref.
+    const match = trimmed.match(/^(.*?)\s+(\d+(?::\S+)?)$/);
+    if (!match) {
+        throw new Error(`Cannot parse reference: "${input}"`);
+    }
+    const bookStr = match[1].trim();
+    const chapterVerseStr = match[2];
+    const book = resolveBook(bookStr);
+    if (!book) {
+        throw new Error(`Unknown book: "${bookStr}"`);
+    }
+    const colonIdx = chapterVerseStr.indexOf(':');
+    if (colonIdx === -1) {
+        return { book, chapter: parseInt(chapterVerseStr, 10) };
+    }
+    const chapter = parseInt(chapterVerseStr.slice(0, colonIdx), 10);
+    let verseStr = chapterVerseStr.slice(colonIdx + 1);
+    // Normalize "chapter:verse-chapter:verse" → "verse-verse" when both chapters match.
+    // e.g. "2:2-2:5" → verseStr goes from "2-2:5" to "2-5"
+    if (verseStr.includes('-')) {
+        const dashIdx = verseStr.indexOf('-');
+        const end = verseStr.slice(dashIdx + 1);
+        if (end.includes(':')) {
+            const endColonIdx = end.indexOf(':');
+            if (parseInt(end.slice(0, endColonIdx), 10) === chapter) {
+                verseStr = verseStr.slice(0, dashIdx + 1) + end.slice(endColonIdx + 1);
+            }
+        }
+    }
+    return { book, chapter, verses: parseVerseSpec(verseStr) };
+}
+// Parse an array of CLI tokens (from commander's variadic arg) into a ParsedRef.
+// Joins tokens and delegates to parseRef.
+// e.g. ['john', '3:16'] → parseRef('john 3:16')
+export function parseRefTokens(tokens) {
+    return parseRef(tokens.join(' '));
+}
+// Parse a multi-ref token list into an array of ParsedRefs.
+// Handles:
+//   - Basic:     ['john', '3:16,18']  →  1 list ref
+//   - Inherited: ['john', '3:16', '3:18']  →  2 refs (book inherited)
+//   - Bare verse: ['Ezek.', '14:14,', '20;', ...]  →  verse 20 inherits chapter 14
+//   - Semicolons: reset chapter context (start of a new book:chapter group)
+//   - Periods:   stripped from book abbreviations (e.g. 'Ezek.' → 'Ezek')
+//   - Quoted:    single-token compound strings are whitespace-split before parsing
+export function parseRefList(tokens) {
+    const refs = [];
+    // Normalize: expand semicolons into separator markers, split on whitespace
+    // (handles quoted compound strings like "Ezek. 14:14, 20; Gen. 6:8"),
+    // then strip trailing commas and periods from each piece.
+    const normalized = tokens
+        .flatMap(t => {
+        const semiParts = t.split(';');
+        return semiParts.flatMap((p, idx) => {
+            const marker = idx < semiParts.length - 1 ? [';'] : [];
+            return [...p.split(/\s+/), ...marker];
+        });
+    })
+        .map(t => t.replace(/,+$/, '').replace(/\.+$/, '').trim())
+        .filter(Boolean);
+    let i = 0;
+    let lastBookRaw = null; // raw (period-stripped) name for parseRef reuse
+    let lastBookAbbr = null; // canonical abbreviation
+    let lastChapter = null;
+    let lastHadVerse = false;
+    while (i < normalized.length) {
+        const token = normalized[i];
+        // Semicolon = reference group boundary: reset verse context so bare numbers
+        // after the semicolon don't incorrectly inherit the previous chapter.
+        if (token === ';') {
+            lastChapter = null;
+            lastHadVerse = false;
+            i++;
+            continue;
+        }
+        // Bare verse number or range (e.g. "20" or "37-39") following a verse-level ref:
+        // inherit book + chapter from previous ref. "14:14, 20" → verse 14 AND verse 20.
+        if (/^\d+(-\d+)?$/.test(token) && lastBookAbbr !== null && lastHadVerse && lastChapter !== null) {
+            const dashIdx = token.indexOf('-');
+            if (dashIdx !== -1) {
+                refs.push({
+                    book: lastBookAbbr,
+                    chapter: lastChapter,
+                    verses: { type: 'range', start: token.slice(0, dashIdx), end: token.slice(dashIdx + 1) },
+                });
+            }
+            else {
+                refs.push({ book: lastBookAbbr, chapter: lastChapter, verses: { type: 'single', verse: token } });
+            }
+            i++;
+            continue;
+        }
+        // Token starts with a digit and we have a prior book: try as chapter[:verse]
+        if (/^\d/.test(token) && lastBookRaw !== null) {
+            try {
+                const ref = parseRef(`${lastBookRaw} ${token}`);
+                refs.push(ref);
+                lastBookAbbr = ref.book;
+                lastChapter = ref.chapter;
+                lastHadVerse = !!ref.verses;
+                i++;
+                continue;
+            }
+            catch {
+                // fall through to book-name scan
+            }
+        }
+        // Scan 1–3 tokens as a book name followed by a chapter[:verse] token
+        let found = false;
+        for (let nameLen = 3; nameLen >= 1; nameLen--) {
+            if (i + nameLen >= normalized.length)
+                continue;
+            const namePart = normalized.slice(i, i + nameLen).join(' ');
+            const chapterToken = normalized[i + nameLen];
+            if (!/^\d/.test(chapterToken))
+                continue;
+            const book = resolveBook(namePart);
+            if (book) {
+                try {
+                    const ref = parseRef(`${namePart} ${chapterToken}`);
+                    refs.push(ref);
+                    lastBookRaw = namePart;
+                    lastBookAbbr = ref.book;
+                    lastChapter = ref.chapter;
+                    lastHadVerse = !!ref.verses;
+                    i += nameLen + 1;
+                    found = true;
+                    break;
+                }
+                catch {
+                    // continue scanning
+                }
+            }
+        }
+        if (!found) {
+            throw new Error(`Cannot parse reference near: "${token}"`);
+        }
+    }
+    return refs;
+}

package/dist/state.d.ts

@@ -0,0 +1,6 @@
+export interface LastRead {
+    book: string;
+    chapter: number;
+}
+export declare function getLastRead(): LastRead | null;
+export declare function saveLastRead(book: string, chapter: number): void;

package/dist/state.js

@@ -0,0 +1,30 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import toml from 'toml';
+const STATE_DIR = join(homedir(), '.rv');
+const STATE_FILE = join(STATE_DIR, 'state.toml');
+export function getLastRead() {
+    try {
+        const raw = readFileSync(STATE_FILE, 'utf-8');
+        const parsed = toml.parse(raw);
+        const lr = parsed?.last_read;
+        if (lr?.book && typeof lr.chapter === 'number') {
+            return { book: lr.book, chapter: lr.chapter };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveLastRead(book, chapter) {
+    try {
+        mkdirSync(STATE_DIR, { recursive: true });
+        const content = `[last_read]\nbook = "${book}"\nchapter = ${chapter}\n`;
+        writeFileSync(STATE_FILE, content, 'utf-8');
+    }
+    catch {
+        // silently ignore — state is non-critical
+    }
+}

package/dist/ui/Pager.d.ts

@@ -0,0 +1,5 @@
+export declare function launchPager(book: string, chapter: number, opts: {
+    notes: boolean;
+    outline: boolean;
+}): Promise<void>;
+export declare function launchPagerHome(): Promise<void>;