udpipe-node 0.1.0

package/dist/cli.js

@@ -0,0 +1,906 @@
+// cli.ts — Interactive CLI for udpipe-node.
+// Launches via "npm start".
+import { createUDPipe, WasmEngine } from './wasm-engine.js';
+import { UDPipe } from './index.js';
+import chalk from 'chalk';
+import readline from 'node:readline';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+// Temporary diagnostic crash logger
+process.on('uncaughtException', (err) => {
+    try {
+        writeFileSync('crash.log', 'Uncaught Exception:\n' + (err.stack || err.message) + '\n');
+    }
+    catch (e) { }
+    console.error(chalk.red('\nUncaught Exception:'), err);
+    process.stdout.write('\u001B[?25h'); // show cursor
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    try {
+        writeFileSync('crash.log', 'Unhandled Rejection:\n' + (err.stack || err.message) + '\n');
+    }
+    catch (e) { }
+    console.error(chalk.red('\nUnhandled Rejection:'), err);
+    process.stdout.write('\u001B[?25h'); // show cursor
+    process.exit(1);
+});
+// Initial loading state
+console.log(chalk.bold.yellow('Loading UDPipe WASM module and English model...'));
+let currentModelPath = 'bundled:english-gum-ud-2.5-191206.udpipe';
+let currentModelName = 'English GUM (UD 2.5)';
+let nlp;
+try {
+    nlp = createUDPipe();
+}
+catch (e) {
+    console.error(chalk.red('Failed to load default WASM engine / model:'), e);
+    process.exit(1);
+}
+// POS tagging color mapping based on Penn Treebank XPOS subtypes
+function getXposColor(xpos) {
+    if (xpos.startsWith('VB') || xpos === 'MD') {
+        return chalk.greenBright; // Verbs
+    }
+    if (xpos.startsWith('NN')) {
+        return chalk.cyanBright; // Nouns
+    }
+    if (xpos.startsWith('PRP') || xpos.startsWith('WP') || xpos === 'EX') {
+        return chalk.cyan; // Pronouns
+    }
+    if (xpos.startsWith('JJ')) {
+        return chalk.yellowBright; // Adjectives
+    }
+    if (xpos.startsWith('RB') || xpos === 'WRB') {
+        return chalk.magentaBright; // Adverbs
+    }
+    if (xpos === 'CC') {
+        return chalk.hex('#FF69B4'); // Coordinating Conjunction (Pink)
+    }
+    if (xpos === 'IN') {
+        return chalk.hex('#FFA500'); // Prepositions / Subordinating Conjunctions (Orange)
+    }
+    if (xpos === 'DT' || xpos === 'PDT' || xpos === 'WDT') {
+        return chalk.gray; // Determiners
+    }
+    if (xpos === 'CD') {
+        return chalk.hex('#8258FA'); // Cardinals
+    }
+    if (['.', ',', ':', '(', ')', '``', "''"].includes(xpos)) {
+        return chalk.dim; // Punctuation
+    }
+    return chalk.white;
+}
+// Dependency relation color mapping as requested
+function getDeprelColor(deprel) {
+    const base = deprel.split(':')[0].toLowerCase();
+    // Nominals (Red shades)
+    if (['nsubj', 'obj', 'iobj', 'dobj'].includes(base)) {
+        return chalk.hex('#FF6B6B'); // Red shade 1 (Nominals Core arguments)
+    }
+    if (['obl', 'pobj'].includes(base)) {
+        return chalk.hex('#FF4757'); // Red shade 2 (Nominals Non-core dependents)
+    }
+    if (['nmod', 'appos', 'nummod', 'poss'].includes(base)) {
+        return chalk.hex('#D63031'); // Red shade 3 (Nominals Nominal dependents)
+    }
+    // Clauses (Blue shades)
+    if (['csubj', 'ccomp', 'xcomp'].includes(base)) {
+        return chalk.hex('#54A0FF'); // Blue shade 1 (Clauses Core arguments)
+    }
+    if (['advcl'].includes(base)) {
+        return chalk.hex('#2E86DE'); // Blue shade 2 (Clauses Non-core dependents)
+    }
+    if (['acl', 'rcmod'].includes(base)) {
+        return chalk.hex('#0984E3'); // Blue shade 3 (Clauses Nominal dependents)
+    }
+    // Modifiers (Green shades)
+    if (['advmod', 'neg'].includes(base)) {
+        return chalk.hex('#2ECC71'); // Green shade 1 (Modifier Non-core)
+    }
+    if (['amod', 'det', 'predet', 'quantmod'].includes(base)) {
+        return chalk.hex('#27AE60'); // Green shade 2 (Modifier Nominal)
+    }
+    // Function words (Greys)
+    if (['mark', 'cop', 'aux'].includes(base)) {
+        return chalk.hex('#A4B0BE'); // Grey shade 1 (Function Words Non-core)
+    }
+    if (['case', 'clf'].includes(base)) {
+        return chalk.hex('#747D8C'); // Grey shade 2 (Function Words Nominal)
+    }
+    // Pink (Coordination Words)
+    if (['cc', 'conj'].includes(base)) {
+        return chalk.hex('#FF69B4');
+    }
+    // Gold (root)
+    if (base === 'root') {
+        return chalk.hex('#FFD700');
+    }
+    // Purple (compounds)
+    if (['compound', 'flat', 'fixed', 'nn', 'mwe'].includes(base)) {
+        return chalk.hex('#A55EEA');
+    }
+    // Default/remaining
+    return chalk.hex('#FF9F43');
+}
+// Print tabular word lists with proper ANSI escape padding alignment
+function printWordTable(words) {
+    const header = 'ID'.padEnd(4) +
+        'FORM'.padEnd(16) +
+        'LEMMA'.padEnd(16) +
+        'UPOS'.padEnd(10) +
+        'XPOS'.padEnd(10) +
+        'HEAD'.padEnd(6) +
+        'DEPREL';
+    console.log('\n' + chalk.bold.blue(header));
+    console.log(chalk.dim('─'.repeat(70)));
+    for (const w of words) {
+        const wordColor = getXposColor(w.xpos);
+        const deprelColor = getDeprelColor(w.deprel);
+        const idStr = chalk.dim(String(w.id).padEnd(4));
+        // Pad first, then apply color so length calculations ignore ANSI codes
+        const formStr = wordColor(w.form.padEnd(16));
+        const lemmaStr = chalk.dim((w.lemma || '_').padEnd(16));
+        const uposStr = wordColor(w.upos.padEnd(10));
+        const xposStr = wordColor(w.xpos.padEnd(10));
+        const headStr = chalk.dim(String(w.head).padEnd(6));
+        const deprelStr = deprelColor(w.deprel);
+        console.log(`${idStr}${formStr}${lemmaStr}${uposStr}${xposStr}${headStr}${deprelStr}`);
+    }
+}
+// Print flat directed graph edges list
+function printGraphEdges(words) {
+    console.log(chalk.bold.yellow('Directed Graph Edges:'));
+    for (const w of words) {
+        const childColor = getXposColor(w.xpos);
+        const deprelColor = getDeprelColor(w.deprel);
+        if (w.head !== 0) {
+            const parentWord = words[w.head - 1];
+            const parentForm = parentWord ? parentWord.form : '?';
+            const parentColor = parentWord ? getXposColor(parentWord.xpos) : chalk.white;
+            console.log(`  ${parentColor(parentForm)} (${chalk.dim(w.head)}) ──[${deprelColor(w.deprel)}]──> ${childColor(w.form)} (${chalk.dim(w.id)})`);
+        }
+        else {
+            console.log(`  ${chalk.bold.hex('#FFD700')('ROOT')} ──[${deprelColor(w.deprel)}]──> ${childColor(w.form)} (${chalk.dim(w.id)})`);
+        }
+    }
+}
+// Render hierarchical dependency tree diagram using Unicode characters
+function renderDependencyTree(words) {
+    const parentToChildren = new Map();
+    for (const w of words) {
+        if (!parentToChildren.has(w.head)) {
+            parentToChildren.set(w.head, []);
+        }
+        parentToChildren.get(w.head).push(w);
+    }
+    // Sort children by ID
+    for (const children of parentToChildren.values()) {
+        children.sort((a, b) => a.id - b.id);
+    }
+    const roots = parentToChildren.get(0) || [];
+    const visited = new Set();
+    function printNode(w, prefix, isLast) {
+        if (visited.has(w.id)) {
+            console.log(`${prefix}${isLast ? '└── ' : '├── '}${chalk.red(`[Cycle detected: ID ${w.id}]`)}`);
+            return;
+        }
+        visited.add(w.id);
+        const wordColor = getXposColor(w.xpos);
+        const deprelColor = getDeprelColor(w.deprel);
+        const nodeStr = `${chalk.dim(w.id + ':')}${wordColor(w.form)} [${chalk.dim(w.xpos)}]`;
+        const relStr = ` ──(${deprelColor(w.deprel)})──>`;
+        console.log(`${prefix}${isLast ? '└── ' : '├── '}${nodeStr}${relStr}`);
+        const children = parentToChildren.get(w.id) || [];
+        const childPrefix = prefix + (isLast ? '    ' : '│   ');
+        for (let i = 0; i < children.length; i++) {
+            printNode(children[i], childPrefix, i === children.length - 1);
+        }
+        visited.delete(w.id);
+    }
+    console.log(chalk.bold.yellow('Dependency Tree Visualization:'));
+    for (let i = 0; i < roots.length; i++) {
+        printNode(roots[i], '', i === roots.length - 1);
+    }
+}
+// Wait for a generic keypress
+function waitForKeypress() {
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        readline.emitKeypressEvents(process.stdin);
+        function onKeypress() {
+            process.stdin.removeListener('keypress', onKeypress);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+            resolve();
+        }
+        process.stdin.once('keypress', onKeypress);
+    });
+}
+// Wait specifically for Enter key
+function waitForEnterKey() {
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        readline.emitKeypressEvents(process.stdin);
+        function onKeypress(str, key) {
+            if (Date.now() - startTime < 100)
+                return;
+            if (key && key.ctrl && key.name === 'c') {
+                process.stdout.write('\u001B[?25h');
+                process.exit(0);
+            }
+            if (key && key.name === 'return') {
+                process.stdin.removeListener('keypress', onKeypress);
+                if (process.stdin.isTTY) {
+                    process.stdin.setRawMode(false);
+                }
+                resolve();
+            }
+        }
+        process.stdin.on('keypress', onKeypress);
+    });
+}
+// Enter multi-line paste/input mode (stops on a blank line)
+function readMultilineInput() {
+    return new Promise((resolve) => {
+        process.stdout.write('\u001B[?25h'); // show cursor
+        console.log(chalk.yellow('\nType or paste your text below.'));
+        console.log(chalk.dim('When finished, press Enter on an empty line to parse:'));
+        console.log(chalk.dim('────────────────────────────────────────────────────────────────────────────────'));
+        const lines = [];
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false
+        });
+        rl.on('line', (line) => {
+            if (line === '') {
+                rl.close();
+            }
+            else {
+                lines.push(line);
+            }
+        });
+        rl.on('close', () => {
+            process.stdout.write('\u001B[?25l'); // hide cursor
+            resolve(lines.join('\n'));
+        });
+    });
+}
+// Enter single-line input mode (for file paths, model paths)
+function readSingleLineInput(promptMsg) {
+    return new Promise((resolve) => {
+        process.stdout.write('\u001B[?25h'); // show cursor
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(promptMsg, (answer) => {
+            rl.close();
+            process.stdout.write('\u001B[?25l'); // hide cursor
+            resolve(answer.trim());
+        });
+    });
+}
+// Prompt to return to the main menu with Enter/Escape support
+function promptReturnToMenu() {
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+        console.log(chalk.bold.yellow('\nYou have reached the end of the parses.'));
+        process.stdout.write(chalk.cyan('Return to the main menu? (y/n) [Enter=Yes, ESC=No]: '));
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        readline.emitKeypressEvents(process.stdin);
+        function onKeypress(str, key) {
+            if (Date.now() - startTime < 100)
+                return;
+            if (key && key.ctrl && key.name === 'c') {
+                process.stdout.write('\u001B[?25h');
+                process.exit(0);
+            }
+            const char = (str || '').toLowerCase();
+            if (char === 'y' || (key && key.name === 'return')) {
+                cleanup();
+                resolve(true);
+            }
+            else if (char === 'n' || (key && key.name === 'escape')) {
+                cleanup();
+                resolve(false);
+            }
+        }
+        function cleanup() {
+            process.stdin.removeListener('keypress', onKeypress);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+        }
+        process.stdin.on('keypress', onKeypress);
+    });
+}
+function getVisibleLength(str) {
+    return str.replace(/\u001B\[[0-9;]*[a-zA-Z]/g, '').length;
+}
+function padVisible(str, targetLen) {
+    const len = getVisibleLength(str);
+    if (len >= targetLen)
+        return str;
+    return str + ' '.repeat(targetLen - len);
+}
+function getLeftUposLines() {
+    const lines = [
+        chalk.bold.hex('#00DEC8')('▼ Universal POS (UPOS)'),
+        chalk.dim('─'.repeat(56))
+    ];
+    const add = (tag, desc, ex) => {
+        lines.push(`  ${chalk.bold.cyan(tag.padEnd(8))} ${desc.padEnd(20)} ${chalk.italic.gray(ex)}`);
+    };
+    add('ADJ', 'Adjective', 'big, red, happy');
+    add('ADP', 'Adposition', 'in, on, to');
+    add('ADV', 'Adverb', 'quickly, here');
+    add('AUX', 'Auxiliary verb', 'has, will, is');
+    add('CCONJ', 'Coord. conj.', 'and, but, or');
+    add('DET', 'Determiner', 'the, a, some');
+    add('INTJ', 'Interjection', 'oh, wow, uh-huh');
+    add('NOUN', 'Common noun', 'cat, water, idea');
+    add('NUM', 'Numeral', '3, first, II');
+    add('PART', 'Particle', "not, 's, to");
+    add('PRON', 'Pronoun', 'I, who, this');
+    add('PROPN', 'Proper noun', 'London, Bell');
+    add('PUNCT', 'Punctuation', ', . ? ! ; :');
+    add('SCONJ', 'Subord. conj.', 'because, if');
+    add('SYM', 'Symbol', '$, %, +, @');
+    add('VERB', 'Verb (main)', 'run, eat, think');
+    add('X', 'Other', 'etc., foobar');
+    return lines;
+}
+function getRightXposLines() {
+    const lines = [
+        chalk.bold.hex('#FF9F43')('▼ English Penn Treebank XPOS'),
+        chalk.dim('─'.repeat(52))
+    ];
+    const add = (tag, desc, ex) => {
+        lines.push(`  ${chalk.bold.cyan(tag.padEnd(6))} ${desc.padEnd(22)} ${chalk.italic.gray(ex)}`);
+    };
+    add('CC', 'Coord. conjunction', 'and, but, or, yet');
+    add('CD', 'Cardinal number', '1, 3.14, 1000');
+    add('DT', 'Determiner', 'the, a, an, this');
+    add('EX', 'Existential there', 'There is hope');
+    add('FW', 'Foreign word', 'vis-à-vis, en route');
+    add('IN', 'Prep / subord conj', 'in, because, if');
+    add('JJ', 'Adjective', 'big, red');
+    add('JJR', 'Adj., comparative', 'bigger, better');
+    add('JJS', 'Adj., superlative', 'biggest, best');
+    add('LS', 'List item marker', '(1), a., •');
+    add('MD', 'Modal', 'can, will, should');
+    add('NN', 'Noun, singular', 'cat, water');
+    add('NNS', 'Noun, plural', 'cats, ideas');
+    add('NNP', 'Proper noun, sing.', 'Bell, Los Angeles');
+    add('NNPS', 'Proper noun, plur.', 'Rockies');
+    add('PDT', 'Predeterminer', 'all, both, half');
+    add('POS', 'Possessive ending', "'s, '");
+    add('PRP', 'Personal pronoun', 'I, you, he, them');
+    add('PRP$', 'Possessive pronoun', 'my, your, his');
+    add('RB', 'Adverb', 'quickly, here');
+    add('RBR', 'Adverb, compar.', 'faster, more');
+    add('RBS', 'Adverb, superl.', 'fastest, most');
+    add('RP', 'Particle', 'up (shut up), off');
+    add('SYM', 'Symbol', '$, %, #');
+    add('TO', 'to infinitive', 'to go, to eat');
+    add('UH', 'Interjection', 'oh, wow');
+    add('VB', 'Verb, base form', 'run, eat');
+    add('VBD', 'Verb, past tense', 'ran, ate, was');
+    add('VBG', 'Verb, gerund/part.', 'running, being');
+    add('VBN', 'Verb, past part.', 'eaten, been');
+    add('VBP', 'Verb, non-3rd pres', 'I run, they eat');
+    add('VBZ', 'Verb, 3rd present', 'he runs, she eats');
+    add('WDT', 'Wh-determiner', 'which, that');
+    add('WP', 'Wh-pronoun', 'who, what, whom');
+    add('WP$', 'Possessive wh-pron', 'whose');
+    add('WRB', 'Wh-adverb', 'how, where, why');
+    return lines;
+}
+function getPage1Lines() {
+    const left = getLeftUposLines();
+    const right = getRightXposLines();
+    const max = Math.max(left.length, right.length);
+    const lines = [];
+    for (let i = 0; i < max; i++) {
+        const l = left[i] || '';
+        const r = right[i] || '';
+        lines.push(padVisible(l, 56) + ' │ ' + r);
+    }
+    return lines;
+}
+function getLeftDeprelLines() {
+    const lines = [];
+    const addHeader = (text) => {
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(chalk.bold.hex('#00DEC8')(`▼ ${text}`));
+        lines.push(chalk.dim('─'.repeat(56)));
+    };
+    const add = (rel, desc, ex) => {
+        lines.push(`  ${getDeprelColor(rel)(rel.padEnd(12))} ${desc.padEnd(16)} ${chalk.italic.gray(ex)}`);
+    };
+    addHeader('Core Arguments (Clausal)');
+    add('nsubj', 'Nominal subject', 'Bell makes');
+    add('nsubj:pass', 'Passive nom subj', 'Dole was defeated');
+    add('obj', 'Direct object', 'reads books');
+    add('iobj', 'Indirect object', 'gave him a book');
+    addHeader('Non-Core Dependents (Clausal)');
+    add('obl', 'Oblique nominal', 'went to Paris');
+    add('obl:agent', 'Oblique agent', 'killed by police');
+    addHeader('Nominal Dependents');
+    add('nmod', 'Nominal modifier', 'the city center');
+    add('nmod:poss', 'Possessive mod', 'their offices');
+    add('appos', 'Appositional', 'Sam, my brother');
+    add('nummod', 'Numeric modifier', '3 sheep');
+    addHeader('Clausal Dependents');
+    add('csubj', 'Clausal subject', 'What she said makes');
+    add('csubj:pass', 'Passive clausal s.', 'That she lied was');
+    add('ccomp', 'Clausal comp.', 'says that you like');
+    add('xcomp', 'Open clausal comp', 'ready to leave');
+    add('advcl', 'Adverbial clause', 'left as night fell');
+    add('acl', 'Adnominal clause', 'the man you love');
+    add('acl:relcl', 'Relative clause', 'book which you bought');
+    return lines;
+}
+function getRightDeprelLines() {
+    const lines = [];
+    const addHeader = (text) => {
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(chalk.bold.hex('#FF9F43')(`▼ ${text}`));
+        lines.push(chalk.dim('─'.repeat(48)));
+    };
+    const add = (rel, desc, ex) => {
+        lines.push(`  ${getDeprelColor(rel)(rel.padEnd(12))} ${desc.padEnd(16)} ${chalk.italic.gray(ex)}`);
+    };
+    addHeader('Modifiers');
+    add('advmod', 'Adverbial mod.', 'genetically modified');
+    add('neg', 'Negation modifier', 'not a scientist');
+    add('amod', 'Adjectival mod.', 'red meat');
+    add('det', 'Determiner', 'the man');
+    addHeader('Function Words');
+    add('aux', 'Auxiliary verb', 'has died');
+    add('aux:pass', 'Passive auxiliary', 'was killed');
+    add('cop', 'Copula', 'is big');
+    add('mark', 'Marker (subord.)', 'left because she');
+    add('case', 'Case-marking', 'in the room');
+    addHeader('Coordination');
+    add('conj', 'Conjunct', 'big and honest');
+    add('cc', 'Coordinating conj.', 'big and honest');
+    add('cc:preconj', 'Preconjunct', 'both boys and girls');
+    addHeader('Compounds & MWE');
+    add('compound', 'Compound', 'ice cream, shut down');
+    add('compound:prt', 'Phrasal verb part', 'shut down, take off');
+    add('flat', 'Flat MWE', 'New York, ad hoc');
+    add('flat:name', 'Name (flat struct)', 'Marie Catherine');
+    add('fixed', 'Fixed MWE', 'because of');
+    addHeader('Root & Other');
+    add('root', 'Root of sentence', 'ROOT → love');
+    add('dep', 'Unspecified dep.', 'fallback case');
+    add('discourse', 'Discourse element', 'well, like, actually');
+    add('expl', 'Expletive', 'There is a ghost');
+    add('goeswith', 'Goes with', 'without');
+    return lines;
+}
+function getPage2Lines() {
+    const left = getLeftDeprelLines();
+    const right = getRightDeprelLines();
+    const max = Math.max(left.length, right.length);
+    const lines = [];
+    for (let i = 0; i < max; i++) {
+        const l = left[i] || '';
+        const r = right[i] || '';
+        lines.push(padVisible(l, 56) + ' │ ' + r);
+    }
+    return lines;
+}
+function getPage3Lines() {
+    const lines = [];
+    const addHeader = (text) => {
+        if (lines.length > 0)
+            lines.push('');
+        lines.push(chalk.bold.hex('#FF9F43')(text));
+        lines.push(chalk.dim('─'.repeat(80)));
+    };
+    const add = (legacy, ud, notes) => {
+        lines.push(`  ${chalk.red(legacy.padEnd(10))} ──>  ${chalk.green(ud.padEnd(12))}  ${chalk.italic.gray(notes)}`);
+    };
+    addHeader('Legacy Stanford Relations (for reference when reading old data)');
+    add('dobj', 'obj', 'Direct object merged into obj');
+    add('pobj', 'obl', 'Object of preposition → oblique');
+    add('nn', 'compound', 'Noun compound modifier');
+    add('mwe', 'fixed', 'Multi-word expression');
+    add('rcmod', 'acl:relcl', 'Relative clause modifier');
+    add('prepc', 'advcl+mark', 'Prepositional clausal modifier');
+    add('agent', 'obl:agent', 'Passive agent (collapsed)');
+    add('xsubj', 'N/A', 'Controlling subject (enhanced only)');
+    addHeader('Key Mappings & Notes');
+    lines.push(chalk.white('  • UPOS VERB/AUX split distinguishes main vs. auxiliary verbs.'));
+    lines.push(chalk.white('  • Penn IN covers both prepositions and subordinating conjunctions;'));
+    lines.push(chalk.white('    UD distinguishes ADP/SCONJ at UPOS level and case/mark at deprel level.'));
+    lines.push(chalk.white("  • 'TO' in Penn is PART in UPOS."));
+    return lines;
+}
+// Loop for paginated parser outputs with arrow key traversal, legend toggle, and Escape exit
+function viewParses(sentences, isVerse, startIndex = 0) {
+    return new Promise((resolve) => {
+        let index = startIndex;
+        let showLegend = false;
+        let legendPage = 0;
+        const startTime = Date.now();
+        function draw() {
+            if (showLegend) {
+                console.clear();
+                console.log(chalk.bold.hex('#FF9F43')(`=== Grammatical Reference: Page ${legendPage + 1} of 3 ===`));
+                console.log(chalk.cyan('Controls: [←/→] Switch Page | [↑/ESC/q] Return to Parses\n'));
+                let lines = [];
+                if (legendPage === 0) {
+                    lines = getPage1Lines();
+                }
+                else if (legendPage === 1) {
+                    lines = getPage2Lines();
+                }
+                else {
+                    lines = getPage3Lines();
+                }
+                for (const line of lines) {
+                    console.log(line);
+                }
+                console.log('\n' + chalk.dim('─'.repeat(100)));
+                return;
+            }
+            console.clear();
+            const unitName = isVerse ? 'Line' : 'Sentence';
+            console.log(chalk.bold.hex('#FF9F43')(`=== ${unitName} ${index + 1} of ${sentences.length} ===`));
+            const s = sentences[index];
+            if (!s) {
+                console.log(chalk.red('Error: Sentence index out of bounds.'));
+                cleanup();
+                resolve();
+                return;
+            }
+            console.log(chalk.bold('\nText: ') + chalk.white(s.text));
+            printWordTable(s.words);
+            console.log(chalk.dim('\n' + '─'.repeat(70)));
+            printGraphEdges(s.words);
+            console.log(chalk.dim('\n' + '─'.repeat(70)));
+            renderDependencyTree(s.words);
+            console.log(chalk.dim('\n' + '─'.repeat(70)));
+            console.log(chalk.cyan('Controls: [→/Enter] Next | [←] Prev | [↓] View Reference Legend | [ESC/q] Exit to Menu'));
+        }
+        draw();
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        readline.emitKeypressEvents(process.stdin);
+        function onKeypress(str, key) {
+            if (Date.now() - startTime < 100)
+                return;
+            if (key && key.ctrl && key.name === 'c') {
+                process.stdout.write('\u001B[?25h'); // show cursor
+                process.exit(0);
+            }
+            if (showLegend) {
+                if (key && key.name === 'up') {
+                    showLegend = false;
+                    draw();
+                }
+                else if (key && key.name === 'left') {
+                    if (legendPage > 0) {
+                        legendPage--;
+                        draw();
+                    }
+                }
+                else if ((key && key.name === 'right') || (key && key.name === 'return')) {
+                    if (legendPage < 2) {
+                        legendPage++;
+                        draw();
+                    }
+                }
+                else if ((key && key.name === 'escape') || str === 'q' || str === 'Q') {
+                    showLegend = false;
+                    draw();
+                }
+                return;
+            }
+            // Escape or 'q' key -> return to main menu
+            if ((key && key.name === 'escape') || str === 'q' || str === 'Q') {
+                cleanup();
+                resolve();
+                return;
+            }
+            if (key && key.name === 'down') {
+                showLegend = true;
+                legendPage = 0;
+                draw();
+            }
+            else if (key && key.name === 'left') {
+                if (index > 0) {
+                    index--;
+                    draw();
+                }
+            }
+            else if ((key && key.name === 'right') || (key && key.name === 'return')) {
+                if (index < sentences.length - 1) {
+                    index++;
+                    draw();
+                }
+                else {
+                    // We are past the last parse! Prompt the user
+                    cleanup();
+                    promptReturnToMenu().then((shouldReturn) => {
+                        if (shouldReturn) {
+                            resolve();
+                        }
+                        else {
+                            // Stay on the last parse screen by restarting the loop at the last index
+                            viewParses(sentences, isVerse, sentences.length - 1).then(resolve);
+                        }
+                    });
+                }
+            }
+        }
+        function onResize() {
+            draw();
+        }
+        function cleanup() {
+            process.stdin.removeListener('keypress', onKeypress);
+            process.stdout.removeListener('resize', onResize);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+        }
+        process.stdin.on('keypress', onKeypress);
+        process.stdout.on('resize', onResize);
+    });
+}
+// Render menu selection
+function selectMenuOption(items) {
+    return new Promise((resolve) => {
+        let selected = 0;
+        function draw() {
+            console.clear();
+            console.log(chalk.bold.hex('#FF9F43')('=== UDPipe 1.4.0 Interactive Parser CLI ==='));
+            console.log(chalk.bold.cyan(`Active Model: `) + chalk.white(currentModelName));
+            console.log(chalk.dim(`Model Path:   ${currentModelPath}\n`));
+            console.log(chalk.dim('Use Up/Down Arrow keys to navigate, press Enter to select.\n'));
+            for (let i = 0; i < items.length; i++) {
+                if (i === selected) {
+                    console.log(chalk.bold.cyan(` › ${items[i]}`));
+                }
+                else {
+                    console.log(chalk.dim(`   ${items[i]}`));
+                }
+            }
+        }
+        draw();
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        readline.emitKeypressEvents(process.stdin);
+        function onKeypress(str, key) {
+            if (key && key.ctrl && key.name === 'c') {
+                process.stdout.write('\u001B[?25h'); // show cursor
+                process.exit(0);
+            }
+            if (key && key.name === 'up') {
+                selected = (selected - 1 + items.length) % items.length;
+                draw();
+            }
+            else if (key && key.name === 'down') {
+                selected = (selected + 1) % items.length;
+                draw();
+            }
+            else if (key && key.name === 'return') {
+                cleanup();
+                resolve(selected);
+            }
+        }
+        function onResize() {
+            draw();
+        }
+        function cleanup() {
+            process.stdin.removeListener('keypress', onKeypress);
+            process.stdout.removeListener('resize', onResize);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+        }
+        process.stdin.on('keypress', onKeypress);
+        process.stdout.on('resize', onResize);
+    });
+}
+// Display POS tag and dependency relation reference
+function showInformation() {
+    return new Promise((resolve) => {
+        let legendPage = 0;
+        const startTime = Date.now();
+        function draw() {
+            console.clear();
+            console.log(chalk.bold.hex('#FF9F43')(`=== Grammatical Reference: Page ${legendPage + 1} of 3 ===`));
+            console.log(chalk.cyan('Controls: [←/→] Switch Page | [ESC/q/Enter] Return to Main Menu\n'));
+            let lines = [];
+            if (legendPage === 0) {
+                lines = getPage1Lines();
+            }
+            else if (legendPage === 1) {
+                lines = getPage2Lines();
+            }
+            else {
+                lines = getPage3Lines();
+            }
+            for (const line of lines) {
+                console.log(line);
+            }
+            console.log('\n' + chalk.dim('─'.repeat(100)));
+        }
+        draw();
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        readline.emitKeypressEvents(process.stdin);
+        function onKeypress(str, key) {
+            if (Date.now() - startTime < 100)
+                return;
+            if (key && key.ctrl && key.name === 'c') {
+                process.stdout.write('\u001B[?25h');
+                process.exit(0);
+            }
+            if ((key && key.name === 'escape') || str === 'q' || str === 'Q') {
+                cleanup();
+                resolve();
+                return;
+            }
+            if (key && key.name === 'left') {
+                if (legendPage > 0) {
+                    legendPage--;
+                    draw();
+                }
+            }
+            else if (key && key.name === 'right') {
+                if (legendPage < 2) {
+                    legendPage++;
+                    draw();
+                }
+            }
+            else if (key && key.name === 'return') {
+                if (legendPage < 2) {
+                    legendPage++;
+                    draw();
+                }
+                else {
+                    cleanup();
+                    resolve();
+                }
+            }
+        }
+        function onResize() {
+            draw();
+        }
+        function cleanup() {
+            process.stdin.removeListener('keypress', onKeypress);
+            process.stdout.removeListener('resize', onResize);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(false);
+            }
+        }
+        process.stdin.on('keypress', onKeypress);
+        process.stdout.on('resize', onResize);
+    });
+}
+const menuItems = [
+    'Verse Mode (Parse pasted text line-by-line)',
+    'Prose Mode (Parse pasted text with sentence segmenter)',
+    'Parse from File (Verse Mode)',
+    'Parse from File (Prose Mode)',
+    'Load Model File (.udpipe model path)',
+    'Information (Reference guide for tags)',
+    'Exit'
+];
+async function mainLoop() {
+    process.stdout.write('\u001B[?25l'); // hide cursor
+    while (true) {
+        const choice = await selectMenuOption(menuItems);
+        if (choice === 0 || choice === 1) {
+            // Verse (0) or Prose (1) mode
+            const isVerse = (choice === 0);
+            const text = await readMultilineInput();
+            if (text.trim() !== '') {
+                console.log(chalk.bold.greenBright('\nPress ENTER to continue...'));
+                await waitForEnterKey();
+                const sentences = isVerse ? nlp.parseLines(text) : nlp.parse(text);
+                await viewParses(sentences, isVerse);
+            }
+        }
+        else if (choice === 2 || choice === 3) {
+            // Parse from File (Verse (2) or Prose (3))
+            const isVerse = (choice === 2);
+            const filepath = await readSingleLineInput('\nEnter the path to the text file to parse: ');
+            if (filepath && existsSync(filepath)) {
+                try {
+                    const text = readFileSync(filepath, 'utf-8');
+                    console.clear();
+                    console.log(chalk.bold.hex('#FF9F43')(`=== File Content Preview (${basename(filepath)}) ===\n`));
+                    const fileLines = text.split('\n');
+                    const preview = fileLines.slice(0, 20).join('\n');
+                    console.log(chalk.white(preview));
+                    if (fileLines.length > 20) {
+                        console.log(chalk.dim(`\n... and ${fileLines.length - 20} more lines`));
+                    }
+                    console.log(chalk.dim('\n' + '─'.repeat(70)));
+                    console.log(chalk.bold.greenBright('Press ENTER to continue...'));
+                    await waitForEnterKey();
+                    const sentences = isVerse ? nlp.parseLines(text) : nlp.parse(text);
+                    await viewParses(sentences, isVerse);
+                }
+                catch (err) {
+                    console.log(chalk.red(`\nError reading file: ${err.message}`));
+                    console.log(chalk.dim('Press any key to return to the main menu...'));
+                    await waitForKeypress();
+                }
+            }
+            else {
+                console.log(chalk.red(`\nFile not found at: ${filepath}`));
+                console.log(chalk.dim('Press any key to return to the main menu...'));
+                await waitForKeypress();
+            }
+        }
+        else if (choice === 4) {
+            // Load Model File
+            const modelpath = await readSingleLineInput('\nEnter the path to your .udpipe model file: ');
+            if (modelpath && existsSync(modelpath)) {
+                try {
+                    console.log(chalk.yellow('\nLoading new model...'));
+                    const newEngine = new WasmEngine({ modelPath: modelpath });
+                    nlp = new UDPipe({ engine: newEngine });
+                    currentModelPath = modelpath;
+                    currentModelName = basename(modelpath);
+                    console.log(chalk.green('✔ Model loaded successfully!'));
+                }
+                catch (err) {
+                    console.log(chalk.red(`\nFailed to load model: ${err.message}`));
+                }
+            }
+            else {
+                console.log(chalk.red(`\nModel file not found at: ${modelpath}`));
+            }
+            console.log(chalk.dim('Press any key to return to the main menu...'));
+            await waitForKeypress();
+        }
+        else if (choice === 5) {
+            // Information Reference
+            await showInformation();
+        }
+        else if (choice === 6) {
+            // Exit
+            console.clear();
+            process.stdout.write('\u001B[?25h'); // show cursor
+            console.log(chalk.green('Goodbye!\n'));
+            process.exit(0);
+        }
+    }
+}
+// Start the application
+mainLoop().catch((err) => {
+    process.stdout.write('\u001B[?25h'); // show cursor
+    console.error(chalk.red('Fatal error in CLI loop:'), err);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map