termux-dev 1.6.0 → 1.8.1

package/dist/cli/typeahead.js

@@ -0,0 +1,371 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { CTRL_ENTER, EXTENDED_KEYS_OFF, EXTENDED_KEYS_ON, normalizeKey, splitKeys } from './keys.js';
+import { buildPromptFrame, palette } from './ui.js';
+import { displayWidth, truncateWidth } from './width.js';
+import { t } from '../core/i18n.js';
+/** The down arrow in every form a terminal may send it: `ESC [ B`, `ESC O B` (application mode), `ESC [ 1 ; mods B` (with modifier fields). */
+const DOWN_ARROW = /^\x1b(?:\[|O)(?:1;[\d:]+)?B$/;
+/** DEVX_DEBUG_KEYS=1: what the terminal sends is written to ~/.devx/keys.log, to find out why a key does nothing. */
+function logKeys(chunk, queued, draft) {
+    try {
+        const file = path.join(os.homedir(), '.devx', 'keys.log');
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, JSON.stringify({ keys: chunk, queued, draftEmpty: draft === '', at: new Date().toISOString() }) + '\n');
+    }
+    catch { }
+}
+const chars = (text) => Array.from(text);
+const isWordChar = (c) => /[\p{L}\p{N}_]/u.test(c);
+/** One key press applied to the draft. The input state is never modified. */
+export function applyKey(state, key) {
+    const cs = chars(state.text);
+    const at = Math.max(0, Math.min(cs.length, state.cursor));
+    const set = (next, cursor) => ({ state: { text: next.join(''), cursor } });
+    const wordBackspace = (chars, pos) => {
+        let start = pos;
+        while (start > 0 && !isWordChar(chars[start - 1]))
+            start--;
+        while (start > 0 && isWordChar(chars[start - 1]))
+            start--;
+        return start === pos ? { state } : set([...chars.slice(0, start), ...chars.slice(pos)], start);
+    };
+    switch (key) {
+        case CTRL_ENTER: {
+            const text = state.text.trim();
+            return { state: text ? { text: '', cursor: 0 } : state, submit: text || undefined, sendNow: true };
+        }
+        case '\r':
+        case '\n': {
+            const text = state.text.trim();
+            return text ? { state: { text: '', cursor: 0 }, submit: text } : { state };
+        }
+        case '\b': // Ctrl+Backspace in most terminals (plain Backspace is 0x7f): erase a word
+            return wordBackspace(cs, at);
+        case '\x7f':
+            return at > 0 ? set([...cs.slice(0, at - 1), ...cs.slice(at)], at - 1) : { state };
+        case '\x1b[3~':
+            return at < cs.length ? set([...cs.slice(0, at), ...cs.slice(at + 1)], at) : { state };
+        case '\x1b[D':
+        case '\x1bOD':
+        case '\x02':
+            return { state: { text: state.text, cursor: Math.max(0, at - 1) } };
+        case '\x1b[C':
+        case '\x1bOC':
+        case '\x06':
+            return { state: { text: state.text, cursor: Math.min(cs.length, at + 1) } };
+        case '\x1b[H':
+        case '\x1b[1~':
+        case '\x1bOH':
+        case '\x01':
+            return { state: { text: state.text, cursor: 0 } };
+        case '\x1b[F':
+        case '\x1b[4~':
+        case '\x1bOF':
+        case '\x05':
+            return { state: { text: state.text, cursor: cs.length } };
+        case '\x15': // Ctrl+U: everything before the cursor
+            return set(cs.slice(at), 0);
+        case '\x0b': // Ctrl+K: everything after the cursor
+            return set(cs.slice(0, at), at);
+        case '\x17': // Ctrl+W, Alt+Backspace: the word before the cursor
+            return wordBackspace(cs, at);
+        case '\x1b': // Esc: throw the line away
+            return state.text ? { state: { text: '', cursor: 0 } } : { state };
+        default:
+            break;
+    }
+    // Any other escape sequence or control character is not text.
+    if (key.startsWith('\x1b') || key.length === 0)
+        return { state };
+    const code = key.codePointAt(0);
+    if (code < 32 || code === 127)
+        return { state };
+    const typed = chars(key);
+    return set([...cs.slice(0, at), ...typed, ...cs.slice(at)], at + typed.length);
+}
+// A stand-in for the cursor while the frame is laid out; it is swapped for a highlighted cell.
+const CURSOR_MARK = '\uE000';
+const CURSOR_CELL = '\x1b[7m \x1b[27m';
+/**
+ * The prompt frame with the line being typed, and under it a row that says what Enter does
+ * or what is already queued. The real cursor is busy marking where the output goes, so the
+ * cursor of the line is drawn as a highlighted cell.
+ */
+export function renderComposer({ state, queued, cols, base }) {
+    const cs = Array.from(state.text);
+    const at = Math.max(0, Math.min(cs.length, state.cursor));
+    const withMark = state.text === '' ? '' : cs.slice(0, at).join('') + CURSOR_MARK + cs.slice(at).join('');
+    let note;
+    const room = Math.max(8, cols - 5);
+    if (queued.length > 0) {
+        const last = queued[queued.length - 1].replace(/\s+/g, ' ');
+        const label = queued.length === 1 ? t('composer.queued') : t('composer.queuedMany', { n: queued.length });
+        const prefix = palette.warn('↳ ' + label) + palette.faint(': ');
+        // What can be done with it: ctrl+enter sends it now, the down arrow takes it back to edit.
+        const hint = t('composer.queuedHint');
+        const suffixWidth = displayWidth(' · ' + hint);
+        const withHint = room - displayWidth(prefix) - suffixWidth >= 12;
+        const message = truncateWidth(last, Math.max(4, room - displayWidth(prefix) - (withHint ? suffixWidth : 0)));
+        note = prefix + palette.muted(message) + (withHint ? palette.faint(' · ') + palette.text(hint) : '');
+    }
+    else {
+        const variants = [t('composer.hint1'), t('composer.hint2'), t('composer.hint3'), t('composer.hint4')];
+        const text = variants.find((v) => displayWidth(v) <= room) ?? '';
+        note = palette.faint(text);
+    }
+    const frame = buildPromptFrame({
+        ...base,
+        cols,
+        input: withMark,
+        cursorPos: withMark === '' ? 0 : at,
+        placeholder: CURSOR_MARK + t('composer.placeholder'),
+        below: [note],
+    });
+    return frame.lines.map((line) => line.split(CURSOR_MARK).join(CURSOR_CELL));
+}
+const MIN_ROWS = 10;
+const MIN_COLS = 30;
+/**
+ * Keeps the prompt frame under the output while a turn runs.
+ *
+ * Every write to the terminal goes through here for the length of the turn: the frame is wiped,
+ * the text is written, the frame is drawn again below the new last line, all in one write, so
+ * the screen does not flicker. The frame needs no fixed place: it is always "the rows under
+ * the cursor", and the cursor is put back where the text goes on. Rows are made with ESC D
+ * (index), which scrolls the screen when the cursor is near the bottom and keeps the column.
+ *
+ * Safe to use anywhere: on a terminal that is too small, or not a terminal at all, it does
+ * nothing and `start()` returns false.
+ */
+export class TurnComposer {
+    out;
+    frameBase;
+    onQueue;
+    status;
+    onSendNow;
+    active = false;
+    suspended = false;
+    shown = false;
+    state = { text: '', cursor: 0 };
+    queue = [];
+    lines = [];
+    original = null;
+    timer = null;
+    /** Called on ctrl+p (thinking) and ctrl+o (tool output). */
+    onToggle;
+    /** The line of live reasoning shown above the working line while thinking is collapsed; empty for none. */
+    live;
+    constructor(out = process.stdout, frameBase, onQueue, 
+    /** The working line shown above the frame for the whole turn; called on every animation tick. */
+    status, 
+    /** Ctrl+Enter: the user wants the queued messages to reach the agent right now. */
+    onSendNow) {
+        this.out = out;
+        this.frameBase = frameBase;
+        this.onQueue = onQueue;
+        this.status = status;
+        this.onSendNow = onSendNow;
+    }
+    get enabled() {
+        return this.active;
+    }
+    /** An approval card or a question has the keyboard. */
+    get isSuspended() {
+        return this.suspended;
+    }
+    get draft() {
+        return this.state.text;
+    }
+    get queued() {
+        return [...this.queue];
+    }
+    hasQueued() {
+        return this.queue.length > 0;
+    }
+    /** Hands over the queued messages (oldest first) and empties the queue. */
+    takeQueued() {
+        const taken = this.queue;
+        this.queue = [];
+        // The "queued" note is part of the frame: it has to be built again, or it stays on screen.
+        this.lines = this.render();
+        this.redraw();
+        return taken;
+    }
+    /** Shows the frame under the cursor and takes over the terminal output. Returns false when that is not possible here. */
+    start(initialDraft = '') {
+        const rows = this.out.rows ?? 0;
+        const cols = this.out.columns ?? 0;
+        if (!this.out.isTTY || rows < MIN_ROWS || cols < MIN_COLS)
+            return false;
+        this.state = { text: initialDraft, cursor: Array.from(initialDraft).length };
+        this.queue = [];
+        this.lines = this.render();
+        // A frame that takes half the screen is not worth it.
+        if (this.lines.length > Math.floor(rows / 2))
+            return false;
+        this.active = true;
+        this.suspended = false;
+        this.shown = false;
+        this.original = this.out.write.bind(this.out);
+        this.out.write = ((chunk, encoding, cb) => this.through(chunk, encoding, cb));
+        this.write(EXTENDED_KEYS_ON + this.drawSeq());
+        // The working line animates: its time and counter are redrawn while the output is quiet.
+        if (this.status) {
+            this.timer = setInterval(() => this.tick(), 60);
+            this.timer.unref?.();
+        }
+        return true;
+    }
+    /** Gives the terminal back and returns what was left unsent. */
+    stop() {
+        const result = { draft: this.state.text, queued: this.queue };
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.active) {
+            this.write(this.eraseSeq() + EXTENDED_KEYS_OFF + '\x1b[?25h');
+            if (this.original)
+                this.out.write = this.original;
+            this.original = null;
+        }
+        this.active = false;
+        this.suspended = false;
+        this.shown = false;
+        this.queue = [];
+        return result;
+    }
+    /** Hides the frame while something else (an approval card, a question) needs the keyboard and the screen. */
+    suspend() {
+        if (!this.active || this.suspended)
+            return;
+        // The card or question that takes over reads plain keys: the extended encodings go off for it.
+        this.write(this.eraseSeq() + EXTENDED_KEYS_OFF);
+        this.suspended = true;
+    }
+    resume() {
+        if (!this.active || !this.suspended)
+            return;
+        this.suspended = false;
+        this.write(EXTENDED_KEYS_ON + this.drawSeq());
+    }
+    /** Builds the frame again (the context percentage or the cost changed) and draws it. */
+    refresh() {
+        this.lines = this.render();
+        this.redraw();
+    }
+    /** The terminal changed size. */
+    onResize() {
+        this.refresh();
+    }
+    /** Raw terminal input. Ignored while suspended. */
+    handleData(chunk) {
+        if (!this.active || this.suspended)
+            return;
+        if (process.env.DEVX_DEBUG_KEYS)
+            logKeys(chunk, this.queue.length, this.state.text);
+        let sendNow = false;
+        for (const raw of splitKeys(chunk)) {
+            const key = normalizeKey(raw);
+            // Ctrl+C is the app's (it stops the generation); Ctrl+D does nothing.
+            if (key === '\x03' || key === '\x04')
+                continue;
+            // Down arrow with nothing typed: the message that waits comes back into the line to be edited.
+            if (DOWN_ARROW.test(key) && this.queue.length > 0 && this.state.text === '') {
+                const back = this.queue.pop();
+                this.state = { text: back, cursor: Array.from(back).length };
+                continue;
+            }
+            if (key === '\x10') {
+                this.onToggle?.('thinking');
+                continue;
+            } // ctrl+p
+            if (key === '\x0f') {
+                this.onToggle?.('output');
+                continue;
+            } // ctrl+o
+            const result = applyKey(this.state, key);
+            this.state = result.state;
+            if (result.submit) {
+                this.queue.push(result.submit);
+                this.onQueue?.(result.submit);
+            }
+            if (result.sendNow && this.queue.length > 0)
+                sendNow = true;
+        }
+        this.lines = this.render();
+        this.redraw();
+        // After the redraw: the caller takes the queue and stops the turn.
+        if (sendNow)
+            this.onSendNow?.();
+    }
+    // ── terminal output
+    /** The write that replaces the terminal's own for the length of the turn. */
+    through(chunk, encoding, cb) {
+        const raw = this.original;
+        if (!this.active || this.suspended)
+            return raw(chunk, encoding, cb);
+        if (typeof chunk === 'string') {
+            // The callback form `write(chunk, cb)` has the callback in the second place.
+            return raw(this.eraseSeq() + chunk + this.drawSeq(), encoding, cb);
+        }
+        raw(this.eraseSeq());
+        const result = raw(chunk, encoding, cb);
+        raw(this.drawSeq());
+        return result;
+    }
+    write(text) {
+        if (text)
+            (this.original ?? this.out.write.bind(this.out))(text);
+    }
+    redraw() {
+        if (!this.active || this.suspended)
+            return;
+        this.write(this.eraseSeq() + this.drawSeq());
+    }
+    /** Redraws the working line only (the frame does not change between ticks). */
+    tick() {
+        if (!this.active || this.suspended || this.lines.length < 3)
+            return;
+        this.lines[1] = this.oneRow(this.live?.() ?? '');
+        this.lines[2] = this.oneRow(this.status?.() ?? '');
+        this.redraw();
+    }
+    /**
+     * The rows under the output: an empty row, the working line, an empty row and the frame.
+     * Without a working line only one empty row separates the frame from the output.
+     */
+    render() {
+        const frame = renderComposer({ state: this.state, queued: this.queue, cols: this.out.columns ?? 80, base: this.frameBase() });
+        // the live reasoning, then the working line right above the frame (always in the same place), and a blank row
+        return this.status ? ['', this.oneRow(this.live?.() ?? ''), this.oneRow(this.status()), '', ...frame] : ['', ...frame];
+    }
+    /** The drawing code moves down one row per line: a line with a line break inside would shift the whole frame. */
+    oneRow(line) {
+        return line.replace(/[\r\n\x00-\x08\x0b-\x1a\x1c-\x1f]+/g, ' ');
+    }
+    /** Wipes the frame: everything under the cursor row. The cursor stays on its text. */
+    eraseSeq() {
+        if (!this.shown)
+            return '';
+        this.shown = false;
+        return '\x1b7\x1b[1B\r\x1b[J\x1b8';
+    }
+    /** Draws the frame under the cursor row and puts the cursor back where the text goes on. */
+    drawSeq() {
+        const lines = this.lines;
+        if (lines.length === 0)
+            return '';
+        this.shown = true;
+        const n = lines.length;
+        // The real cursor only marks where the output goes on. Whatever showed it in the meantime
+        // (an approval card, a spinner that stopped) must not leave it blinking under the output.
+        // ESC D moves down (scrolling at the bottom edge) and keeps the column; then back up.
+        let seq = '\x1b[?25l' + '\x1bD'.repeat(n) + `\x1b[${n}A` + '\x1b7';
+        for (const line of lines)
+            seq += `\x1b[1B\r\x1b[2K${line}\x1b[0m`;
+        return seq + '\x1b8';
+    }
+}