termux-dev 1.6.0 → 1.8.1

package/dist/cli/keys.js

@@ -0,0 +1,69 @@
+// One terminal "key": a full escape sequence (arrows, Home, Delete...), Alt+Enter, Alt+Backspace, a lone Esc,
+// or a single character. The `u` flag keeps characters outside the BMP in one piece.
+const KEY = /\x1b\[[0-9;:?]*[ -/]*[@-~]|\x1bO[\s\S]|\x1b[\r\n\x7f]|\x1b|[\s\S]/gu;
+/**
+ * Splits raw input into separate key presses.
+ *
+ * A terminal may deliver several keys in one chunk (holding an arrow key, a fast typist, a
+ * slow connection, Termux batching input), for example "\x1b[B\x1b[B\x1b[B" for three
+ * presses of Down. Code that compares a whole chunk with one key would miss them all.
+ */
+export function splitKeys(chunk) {
+    return chunk.match(KEY) ?? [];
+}
+/** Erases the word before the cursor (Ctrl+W in a shell); Ctrl+Backspace and Alt+Backspace are mapped to it. */
+export const WORD_BACKSPACE = '\x17';
+/** What a terminal sends for Ctrl+Enter once the extended keyboard modes below are on. */
+export const CTRL_ENTER = '\x1b[13;5u';
+/**
+ * Asks the terminal to tell Ctrl+Enter apart from Enter (a plain terminal sends the same
+ * byte for both). Two protocols are requested, a terminal answers the one it knows:
+ * the kitty keyboard protocol (kitty, foot, ghostty, wezterm, alacritty, ...) and xterm's
+ * modifyOtherKeys. Terminals that know neither ignore both, and Alt+Enter still works.
+ * While on, the keys arrive as `CSI … u`: run them through `normalizeKey`.
+ */
+export const EXTENDED_KEYS_ON = '\x1b[>1u\x1b[>4;1m';
+export const EXTENDED_KEYS_OFF = '\x1b[<u\x1b[>4;0m';
+/**
+ * Turns the extended encodings back into the keys the rest of the code knows:
+ * `CSI 99;5u` and `CSI 27;5;99~` become Ctrl+C (0x03), `CSI 27u` becomes Esc, and every way
+ * of sending Ctrl+Enter or Alt+Enter becomes `CTRL_ENTER`. Anything else is returned as is.
+ */
+export function normalizeKey(key) {
+    if (key === '\x1b\r' || key === '\x1b\n')
+        return CTRL_ENTER;
+    if (key === '\x1b\x7f')
+        return WORD_BACKSPACE; // Alt+Backspace
+    const m = /^\x1b\[(?:27;(\d+);(\d+)~|(\d+)(?:;(\d+))?(?::\d+)?u)$/.exec(key);
+    if (!m)
+        return key;
+    // modifyOtherKeys is `27;mods;code`, the kitty protocol is `code;mods`.
+    const code = Number(m[2] ?? m[3]);
+    const mods = Math.max(0, Number(m[1] ?? m[4] ?? 1) - 1);
+    const shift = (mods & 1) !== 0;
+    const alt = (mods & 2) !== 0;
+    const ctrl = (mods & 4) !== 0;
+    // Ctrl+Backspace and Alt+Backspace: erase a word.
+    if ((code === 127 || code === 8) && (ctrl || alt))
+        return WORD_BACKSPACE;
+    if (code === 13 || code === 10)
+        return ctrl || alt ? CTRL_ENTER : shift ? key : '\r';
+    if (alt)
+        return key;
+    if (ctrl) {
+        if (code >= 97 && code <= 122)
+            return String.fromCharCode(code - 96);
+        if (code >= 65 && code <= 90)
+            return String.fromCharCode(code - 64);
+        return key;
+    }
+    if (code === 27)
+        return '\x1b';
+    if (code === 9)
+        return '\t';
+    if (code === 127 || code === 8)
+        return String.fromCharCode(code);
+    if (code >= 32 && code !== 127 && !shift)
+        return String.fromCodePoint(code);
+    return key;
+}

package/dist/cli/liveblock.js

@@ -0,0 +1,45 @@
+/**
+ * A block of terminal rows that is redrawn in place.
+ *
+ * The cursor rests on the last row of the block. A redraw goes back up to the first row,
+ * rewrites every row and wipes the rows left over from a taller previous version, so the
+ * screen never grows however often the content changes. The cursor is hidden while the
+ * block is on screen.
+ */
+export class LiveBlock {
+    out;
+    rows = 0;
+    constructor(out) {
+        this.out = out;
+    }
+    get height() {
+        return this.rows;
+    }
+    draw(lines) {
+        let buf = '\x1b[?25l';
+        if (this.rows > 1)
+            buf += `\x1b[${this.rows - 1}A`;
+        buf += '\r';
+        lines.forEach((line, i) => {
+            buf += '\x1b[2K' + line + '\x1b[0m' + (i < lines.length - 1 ? '\n' : '');
+        });
+        let extra = 0;
+        for (let k = lines.length; k < this.rows; k++) {
+            buf += '\n\x1b[2K';
+            extra++;
+        }
+        if (extra > 0)
+            buf += `\x1b[${extra}A`;
+        this.out.write(buf);
+        this.rows = lines.length;
+    }
+    /** Removes the block from the screen and shows the cursor again. */
+    erase() {
+        if (this.rows === 0) {
+            this.out.write('\x1b[?25h');
+            return;
+        }
+        this.out.write(`\r${this.rows > 1 ? `\x1b[${this.rows - 1}A` : ''}\x1b[J\x1b[?25h`);
+        this.rows = 0;
+    }
+}

package/dist/cli/log.js

@@ -0,0 +1,19 @@
+import { palette, renderNotice } from './ui.js';
+import { stripAnsi } from './width.js';
+const print = (kind, message) => console.log(renderNotice(kind, stripAnsi(message)));
+export const log = {
+    info: (message) => print('info', message),
+    success: (message) => print('ok', message),
+    warn: (message) => print('warn', message),
+    error: (message) => print('error', message),
+    message: (message) => print('info', message),
+};
+/** A titled block of lines (the command list, the config), rows kept as they are. */
+export function note(text, title = '') {
+    console.log();
+    if (title)
+        console.log('  ' + palette.bold(palette.accent(title)));
+    for (const row of stripAnsi(text).split('\n'))
+        console.log('    ' + palette.muted(row));
+    console.log();
+}

package/dist/cli/logo.js

@@ -0,0 +1,30 @@
+/**
+ * The devx wordmark, drawn from a small pixel font: every letter is 5 pixels wide and 6 tall, and two
+ * pixel rows share one terminal row with half blocks, so the pixels are square and the shapes stay clean.
+ */
+const FONT = {
+    D: ['████ ', '█   █', '█   █', '█   █', '█   █', '████ '],
+    E: ['█████', '█    ', '████ ', '█    ', '█    ', '█████'],
+    V: ['█   █', '█   █', '█   █', '█   █', ' █ █ ', '  █  '],
+    X: ['█   █', ' █ █ ', '  █  ', '  █  ', ' █ █ ', '█   █'],
+};
+export function wordmark(text = 'DEVX', gap = 1) {
+    const letters = Array.from(text).map((c) => FONT[c]);
+    const rows = letters[0].length;
+    const out = [];
+    for (let r = 0; r < rows; r += 2) {
+        let line = '';
+        letters.forEach((glyph, i) => {
+            if (i > 0)
+                line += ' '.repeat(gap);
+            for (let x = 0; x < glyph[r].length; x++) {
+                const top = glyph[r][x] !== ' ';
+                const bottom = glyph[r + 1][x] !== ' ';
+                line += top && bottom ? '█' : top ? '▀' : bottom ? '▄' : ' ';
+            }
+        });
+        out.push(line);
+    }
+    return out;
+}
+export const DEVX_LOGO = wordmark();

package/dist/cli/markdown.js

@@ -1,16 +1,124 @@
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import pc from 'picocolors';
+import { palette } from './ui.js';
 marked.use(markedTerminal({
     width: Math.min(process.stdout.columns || 80, 100),
     reflowText: false,
+    showSectionPrefix: false,
     tab: 2
 }));
+// marked-terminal prints the text of a list item as it was written (`code` and **bold** with their
+// marks); the inline tokens of the item have to be rendered.
+marked.use({
+    renderer: {
+        text(token) {
+            if (token && typeof token === 'object' && Array.isArray(token.tokens) && token.tokens.length > 0) {
+                return this.parser.parseInline(token.tokens);
+            }
+            return false;
+        },
+    },
+});
+/**
+ * Inline markdown (`code`, **bold**, *italic*) for text that arrives in pieces. The state of an open
+ * marker is kept between pieces, so a span that runs over several words (`**seven words in bold**`)
+ * is styled as a whole and the marks themselves never reach the screen. A mark that cannot be a
+ * mark (`2 * 3`, a lone `*`) stays as it is. Every piece is closed at its end and opened again at
+ * the start of the next one, so a line that is wrapped or cut in between stays well-formed.
+ */
+export class InlineStyler {
+    bold = false;
+    italic = false;
+    code = false;
+    /** The character before the next one: whether a mark opens or closes depends on it. */
+    prev = ' ';
+    codeOn;
+    codeOff;
+    constructor() {
+        const [on, off] = palette.warn('\u0001').split('\u0001');
+        this.codeOn = on ?? '';
+        this.codeOff = off ?? '';
+    }
+    /** A new line: nothing stays open across a line break. */
+    endLine() {
+        this.bold = this.italic = this.code = false;
+        this.prev = ' ';
+    }
+    open() {
+        return (this.bold ? '\x1b[1m' : '') + (this.italic ? '\x1b[3m' : '') + (this.code ? this.codeOn : '');
+    }
+    close() {
+        return (this.code ? this.codeOff : '') + (this.italic ? '\x1b[23m' : '') + (this.bold ? '\x1b[22m' : '');
+    }
+    format(text) {
+        if (!text)
+            return '';
+        const colour = !!(pc.isColorSupported);
+        let out = colour ? this.open() : '';
+        const chars = Array.from(text);
+        const isWord = (c) => !!c && /[\p{L}\p{N}]/u.test(c);
+        const isSpace = (c) => c === undefined || /\s/.test(c);
+        for (let i = 0; i < chars.length; i++) {
+            const c = chars[i];
+            const next = chars[i + 1];
+            if (c === '`') {
+                // A code span: inside it nothing else is a mark.
+                this.code = !this.code;
+                out += colour ? (this.code ? this.codeOn : this.codeOff) : '';
+                this.prev = c;
+                continue;
+            }
+            if (this.code) {
+                out += c;
+                this.prev = c;
+                continue;
+            }
+            if (c === '*' && next === '*') {
+                const after = chars[i + 2];
+                const opens = !this.bold && !isSpace(after) && after !== '*' && !isWord(this.prev);
+                const closes = this.bold && !isSpace(this.prev);
+                if (opens || closes) {
+                    this.bold = opens;
+                    out += colour ? (opens ? '\x1b[1m' : '\x1b[22m') : '';
+                    i++;
+                    this.prev = '*';
+                    continue;
+                }
+            }
+            else if (c === '*') {
+                const opens = !this.italic && !isSpace(next) && next !== '*' && !isWord(this.prev);
+                const closes = this.italic && !isSpace(this.prev) && !isWord(next);
+                if (opens || closes) {
+                    this.italic = opens;
+                    out += colour ? (opens ? '\x1b[3m' : '\x1b[23m') : '';
+                    this.prev = '*';
+                    continue;
+                }
+            }
+            out += c;
+            this.prev = c;
+        }
+        return out + (colour ? this.close() : '');
+    }
+}
+/** Width of horizontal rules / code frames: leaves room for the 2-column gutter. */
+function ruleWidth(max) {
+    return Math.max(10, Math.min((process.stdout.columns || 40) - 4, max));
+}
+/** A code fence of the language `markdown` / `md` holds markdown to be shown formatted, not source to be shown as it is (`/copy` gives the source). */
+const MD_FENCE_LANG = /^(?:markdown|md)$/i;
+/** Takes the fences off ```markdown blocks so that their content is rendered as markdown. */
+export function unfenceMarkdown(text) {
+    return text.replace(/^[ \t]*```[ \t]*(?:markdown|md)[^\n]*\n([\s\S]*?)^[ \t]*```[ \t]*$/gim, (_m, body) => body.replace(/\n$/, ''));
+}
 export function renderMarkdown(content) {
     if (!content)
         return '';
     try {
-        return marked.parse(content).trim();
+        const text = marked.parse(unfenceMarkdown(content)).trim();
+        // The list marker of marked-terminal is `*`: draw a bullet instead.
+        return text.replace(/^((?:\s|\x1b\[[0-9;]*m)*)\* /gm, '$1• ');
     }
     catch {
         return content;
@@ -21,11 +129,23 @@ export function renderMarkdown(content) {
  * Avoids heavy synchronous AST re-parsing on every chunk, keeping token streaming buttery smooth.
  */
 export class MarkdownStreamer {
+    sink = (text) => {
+        process.stdout.write(text);
+    };
     buffer = '';
     inCodeBlock = false;
+    /** Inside a ```markdown fence: the lines are markdown, drawn formatted and without a frame. */
+    inMdFence = false;
     codeBlockLang = '';
     inTable = false;
     tableBuffer = [];
+    styler = new InlineStyler();
+    /** The buffer starts a line. After words of a line were written it does not: its rest is prose, not a list item or a heading. */
+    atLineStart = true;
+    /** Redirects the output (e.g. through a GutterWriter). Defaults to stdout. */
+    setSink(sink) {
+        this.sink = sink;
+    }
     push(chunk) {
         this.buffer += chunk;
         // 1. Process completed lines
@@ -33,13 +153,20 @@ export class MarkdownStreamer {
             const lines = this.buffer.split('\n');
             this.buffer = lines.pop() || '';
             for (const line of lines) {
-                this.processLine(line);
+                if (this.atLineStart)
+                    this.processLine(line);
+                else
+                    this.sink(this.formatInline(line) + '\n');
+                this.atLineStart = true;
+                this.styler.endLine();
             }
         }
         // 2. Stream regular prose words immediately in real-time
         if (!this.inCodeBlock && !this.inTable && this.buffer.length > 0) {
             const trimmed = this.buffer.trimStart();
-            const isSpecialLine = trimmed.startsWith('#') ||
+            // Only spaces so far (the indent of a nested item): wait for what follows.
+            const onlyBlank = trimmed.length === 0;
+            const isSpecialLine = onlyBlank || this.atLineStart && (trimmed.startsWith('#') ||
                 trimmed.startsWith('|') ||
                 trimmed.startsWith('```') ||
                 trimmed.startsWith('- [') ||
@@ -51,13 +178,15 @@ export class MarkdownStreamer {
                 /^\d+\.\s/.test(trimmed) ||
                 trimmed.startsWith('> ') ||
                 trimmed === '---' ||
-                trimmed === '***';
+                trimmed === '***');
             if (!isSpecialLine) {
                 const lastSpaceIdx = Math.max(this.buffer.lastIndexOf(' '), this.buffer.lastIndexOf('\t'));
-                if (lastSpaceIdx > 0) {
+                // At the start of a line, a first word that is not finished yet (`  *`, the marker of an indented item) waits.
+                if (lastSpaceIdx > 0 && (!this.atLineStart || /\S\s/.test(this.buffer))) {
                     const wordsToFlush = this.buffer.slice(0, lastSpaceIdx + 1);
                     this.buffer = this.buffer.slice(lastSpaceIdx + 1);
-                    process.stdout.write(this.formatInline(wordsToFlush));
+                    this.sink(this.formatInline(wordsToFlush));
+                    this.atLineStart = false;
                 }
             }
         }
@@ -66,23 +195,31 @@ export class MarkdownStreamer {
         const trimmed = line.trim();
         // 1. Code block boundary
         if (trimmed.startsWith('```')) {
+            if (this.inMdFence) {
+                this.inMdFence = false;
+                return;
+            }
+            if (!this.inCodeBlock && MD_FENCE_LANG.test(trimmed.slice(3).trim().split(/\s+/)[0] ?? '')) {
+                this.inMdFence = true;
+                return;
+            }
             if (this.inCodeBlock) {
                 this.inCodeBlock = false;
                 this.codeBlockLang = '';
-                process.stdout.write(pc.dim('└' + '─'.repeat(Math.min(process.stdout.columns || 40, 50))) + '\n');
+                this.sink(palette.rule('└' + '─'.repeat(ruleWidth(50))) + '\n');
                 return;
             }
             else {
                 this.inCodeBlock = true;
                 this.codeBlockLang = trimmed.slice(3).trim();
                 const langTag = this.codeBlockLang ? ` [${this.codeBlockLang}] ` : ' ';
-                process.stdout.write('\n' + pc.cyan('┌─' + langTag + '─'.repeat(Math.max(2, Math.min(process.stdout.columns || 40, 50) - langTag.length - 2))) + '\n');
+                this.sink('\n' + palette.accent('┌─' + langTag + '─'.repeat(Math.max(2, ruleWidth(50) - langTag.length - 2))) + '\n');
                 return;
             }
         }
         // 2. Inside code block: fast syntax-tinted output
         if (this.inCodeBlock) {
-            process.stdout.write(pc.green('│ ') + pc.white(line) + '\n');
+            this.sink(palette.rule('│ ') + palette.text(line) + '\n');
             return;
         }
         // 3. Tables
@@ -101,73 +238,68 @@ export class MarkdownStreamer {
             const mark = todoMatch[2].toLowerCase();
             const taskText = this.formatInline(todoMatch[3]);
             if (mark === 'x' || mark === '✓') {
-                process.stdout.write('  ' + pc.green('[✓] ') + pc.dim(taskText) + '\n');
+                this.sink('  ' + palette.ok('[✓] ') + palette.faint(taskText) + '\n');
             }
             else if (mark === '/' || mark === '>') {
-                process.stdout.write('  ' + pc.bold(pc.green('[ ] ' + taskText)) + '\n');
+                this.sink('  ' + palette.bold(palette.ok('[ ] ' + taskText)) + '\n');
             }
             else {
-                process.stdout.write('  ' + pc.dim('[ ] ') + pc.white(taskText) + '\n');
+                this.sink('  ' + palette.faint('[ ] ') + palette.text(taskText) + '\n');
             }
             return;
         }
         // 5. OpenCode Action arrows (→ Read ..., → Edit ...)
         if (trimmed.startsWith('→ ')) {
-            process.stdout.write(pc.bold(pc.cyan('→ ')) + pc.white(this.formatInline(trimmed.slice(2))) + '\n');
+            this.sink(palette.bold(palette.accent('→ ')) + palette.text(this.formatInline(trimmed.slice(2))) + '\n');
             return;
         }
         // 6. Regular line fast formatting (Headers, Bullets, Bold, Dims)
+        const plainMarks = (text) => text.replace(/\*{1,2}([^*\n]+)\*{1,2}/g, '$1').replace(/`/g, '');
         if (trimmed.startsWith('# ')) {
-            process.stdout.write('\n' + pc.bold(pc.cyan(trimmed.slice(2))) + '\n\n');
+            this.sink('\n' + palette.bold(palette.accent(plainMarks(trimmed.slice(2)))) + '\n\n');
         }
         else if (trimmed.startsWith('## ')) {
-            process.stdout.write('\n' + pc.bold(pc.white(trimmed.slice(3))) + '\n');
+            this.sink('\n' + palette.bold(palette.text(plainMarks(trimmed.slice(3)))) + '\n');
         }
-        else if (trimmed.startsWith('### ')) {
-            process.stdout.write('\n' + pc.bold(pc.yellow(trimmed.slice(4))) + '\n');
+        else if (/^#{3,6} /.test(trimmed)) {
+            this.sink('\n' + palette.bold(palette.warn(plainMarks(trimmed.replace(/^#+ /, '')))) + '\n');
         }
         else if (trimmed.startsWith('- ') || trimmed.startsWith('* ')) {
-            process.stdout.write('  ' + pc.cyan('• ') + this.formatInline(line.slice(2)) + '\n');
+            // A nested item keeps its indentation.
+            const indent = ' '.repeat(Math.min(8, line.length - line.trimStart().length));
+            this.sink('  ' + indent + palette.accent('• ') + this.formatInline(trimmed.slice(2)) + '\n');
         }
         else if (/^\d+\.\s/.test(trimmed)) {
             const match = trimmed.match(/^(\d+\.)\s*(.*)$/);
             if (match) {
-                process.stdout.write('  ' + pc.cyan(match[1]) + ' ' + this.formatInline(match[2]) + '\n');
+                this.sink('  ' + palette.accent(match[1]) + ' ' + this.formatInline(match[2]) + '\n');
             }
             else {
-                process.stdout.write(this.formatInline(line) + '\n');
+                this.sink(this.formatInline(line) + '\n');
             }
         }
         else if (trimmed.startsWith('> ')) {
-            process.stdout.write(pc.dim('  │ ' + trimmed.slice(2)) + '\n');
+            this.sink(palette.faint('  │ ') + this.formatInline(trimmed.slice(2)) + '\n');
         }
         else if (trimmed === '---' || trimmed === '***' || trimmed === '___') {
-            process.stdout.write(pc.dim('─'.repeat(Math.min(process.stdout.columns || 40, 60))) + '\n');
+            this.sink(palette.rule('─'.repeat(ruleWidth(60))) + '\n');
         }
         else {
-            process.stdout.write(this.formatInline(line) + '\n');
+            this.sink(this.formatInline(line) + '\n');
         }
     }
     formatInline(text) {
-        if (!text)
-            return '';
-        // Format `code`
-        let formatted = text.replace(/`([^`]+)`/g, (_, c) => pc.yellow(c));
-        // Format **bold**
-        formatted = formatted.replace(/\*\*([^*]+)\*\*/g, (_, b) => pc.bold(b));
-        // Format *italic*
-        formatted = formatted.replace(/\*([^*]+)\*/g, (_, i) => pc.italic(i));
-        return formatted;
+        return this.styler.format(text);
     }
     flushTable() {
         if (this.tableBuffer.length > 0) {
             const tableMd = this.tableBuffer.join('\n');
             try {
                 const rendered = renderMarkdown(tableMd);
-                process.stdout.write(rendered + '\n');
+                this.sink(rendered + '\n');
             }
             catch {
-                process.stdout.write(tableMd + '\n');
+                this.sink(tableMd + '\n');
             }
             this.tableBuffer = [];
         }
@@ -175,9 +307,12 @@ export class MarkdownStreamer {
     reset() {
         this.buffer = '';
         this.inCodeBlock = false;
+        this.inMdFence = false;
         this.codeBlockLang = '';
         this.inTable = false;
         this.tableBuffer = [];
+        this.atLineStart = true;
+        this.styler.endLine();
     }
     finish() {
         if (this.buffer) {
@@ -190,14 +325,16 @@ export class MarkdownStreamer {
         this.flushTable();
         if (this.buffer) {
             if (this.inCodeBlock) {
-                process.stdout.write(pc.green('│ ') + pc.white(this.buffer) + '\n');
-                process.stdout.write(pc.dim('└' + '─'.repeat(Math.min(process.stdout.columns || 40, 50))) + '\n');
+                this.sink(palette.rule('│ ') + palette.text(this.buffer) + '\n');
+                this.sink(palette.rule('└' + '─'.repeat(ruleWidth(50))) + '\n');
                 this.inCodeBlock = false;
             }
             else {
-                process.stdout.write(this.formatInline(this.buffer) + '\n');
+                this.sink(this.formatInline(this.buffer) + '\n');
             }
             this.buffer = '';
+            this.atLineStart = true;
+            this.styler.endLine();
         }
     }
 }