micro-models-agent 0.47.0 → 0.48.1

package/dist/ui/line-editor.js

@@ -0,0 +1,703 @@
+import * as readline from "readline";
+import stringWidth from "string-width";
+import { buildLayout, layoutIndexFor, visualColAt, charOffsetFor, charLen, stripAnsi, } from "./line-math";
+export class LineEditor {
+    input;
+    output;
+    /** Host hook: return true to swallow the key before the editor handles it. */
+    onKeyInput;
+    promptStr;
+    completer;
+    history;
+    historySize;
+    lines = [""];
+    row = 0;
+    col = 0;
+    historyIndex = -1;
+    stash = null;
+    isDone = false;
+    isPaste = false;
+    /** Pasted characters accumulated between `paste-start` and `paste-end`.
+     *  Inserted as a single batch on `paste-end` — one render instead of one
+     *  per keypress, so a paste appears as a paste, not as fast typing. */
+    pasteBuffer = "";
+    /** Whether the last paste keypress was a bare CR — used to collapse a
+     *  CRLF pair into a single newline (Windows clipboard text). */
+    pasteLastWasCR = false;
+    lastWasCR = false;
+    questionCb = null;
+    rawMode = false;
+    listeners = {};
+    /** Visual row (within the drawn frame) where the cursor was placed by the
+     *  last render — used to move back to the frame's first row before
+     *  redrawing, so a redraw starting on a middle/bottom row never leaves
+     *  stale lines above (duplicated input text on newline). */
+    prevCursorRow = 0;
+    constructor(opts) {
+        this.input = opts.input;
+        this.output = opts.output;
+        this.promptStr = opts.prompt ?? "";
+        this.completer = opts.completer;
+        this.history = opts.history ?? [];
+        this.historySize = opts.historySize ?? 50;
+        if (this.history.length > this.historySize) {
+            this.history = this.history.slice(-this.historySize);
+        }
+        if (this.input.isTTY) {
+            this.rawMode = typeof this.input.setRawMode === "function";
+            if (this.rawMode)
+                this.input.setRawMode(true);
+            this.enableTerminalProtocols();
+            readline.emitKeypressEvents(this.input);
+            this.input.on("keypress", (str, key) => this.onKey(str, key));
+        }
+        else {
+            this.input.on("data", (buf) => this.onData(buf));
+            this.input.on("end", () => {
+                const last = this.lines.join("\n");
+                this.lines = [""];
+                this.row = 0;
+                this.col = 0;
+                if (last)
+                    this.emitLine(last);
+                this.emitClose();
+            });
+        }
+    }
+    on(event, listener) {
+        if (event === "line") {
+            this.listeners.line = listener;
+        }
+        else {
+            this.listeners.close = listener;
+        }
+        return this;
+    }
+    setPrompt(prompt) {
+        this.promptStr = prompt;
+        if (this.input.isTTY)
+            this.render();
+    }
+    prompt(_preserveCursor) {
+        if (this.input.isTTY)
+            this.render();
+    }
+    write(s) {
+        this.insertText(s);
+    }
+    reset() {
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        this.historyIndex = -1;
+        this.stash = null;
+        this.prevCursorRow = 0;
+        if (this.input.isTTY)
+            this.render();
+    }
+    question(query, cb) {
+        this.questionCb = cb;
+        this.promptStr = query;
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        this.prevCursorRow = 0;
+        if (this.input.isTTY)
+            this.render();
+    }
+    close() {
+        if (this.isDone)
+            return;
+        this.isDone = true;
+        this.disableTerminalProtocols();
+        if (this.rawMode && this.input.setRawMode) {
+            this.input.setRawMode(false);
+        }
+        this.emitClose();
+    }
+    // ---- input handling ----
+    onData(buf) {
+        if (this.isDone)
+            return;
+        let text = buf.toString("utf-8");
+        text = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+        const parts = text.split("\n");
+        for (let i = 0; i < parts.length; i++) {
+            if (i < parts.length - 1) {
+                this.emitLine(parts[i]);
+                this.lines = [""];
+                this.row = 0;
+                this.col = 0;
+            }
+            else if (parts[i]) {
+                this.emitLine(parts[i]);
+                this.lines = [""];
+                this.row = 0;
+                this.col = 0;
+            }
+        }
+    }
+    onKey(str, key) {
+        if (this.isDone)
+            return;
+        if (this.onKeyInput && this.onKeyInput(str, key))
+            return;
+        const k = key;
+        const name = k?.name ?? "undefined";
+        const seq = k?.sequence ?? str ?? "";
+        if (name === "undefined" && /^\x1b\[\d+(?:;\d+)?u$/.test(seq)) {
+            const m = seq.match(/^\x1b\[(\d+)(?:;(\d+))?u$/);
+            if (m && Number(m[1]) === 13 && Number(m[2] ?? 0) !== 0) {
+                this.insertNewline();
+            }
+            return;
+        }
+        if (name === "paste-start" || seq === "\x1b[200~") {
+            this.isPaste = true;
+            this.pasteBuffer = "";
+            this.pasteLastWasCR = false;
+            return;
+        }
+        if (name === "paste-end" || seq === "\x1b[201~") {
+            this.isPaste = false;
+            if (this.pasteBuffer) {
+                this.insertPaste(this.pasteBuffer);
+            }
+            else {
+                this.render();
+            }
+            this.pasteBuffer = "";
+            this.pasteLastWasCR = false;
+            return;
+        }
+        if (this.isPaste) {
+            if (name === "return" || seq === "\r") {
+                this.pasteBuffer += "\n";
+                this.pasteLastWasCR = true;
+            }
+            else if (name === "enter" || seq === "\n") {
+                if (this.pasteLastWasCR) {
+                    this.pasteLastWasCR = false;
+                }
+                else {
+                    this.pasteBuffer += "\n";
+                }
+            }
+            else if (str) {
+                this.pasteLastWasCR = false;
+                this.pasteBuffer += str;
+            }
+            return;
+        }
+        if (name === "return" && (seq === "\x1b\r" || k.meta)) {
+            this.insertNewline();
+            return;
+        }
+        if (name === "undefined" && seq === "\x1b\r") {
+            this.insertNewline();
+            return;
+        }
+        if (k?.ctrl && name === "j") {
+            this.insertNewline();
+            return;
+        }
+        if (name === "escape")
+            return;
+        switch (name) {
+            case "return":
+                this.lastWasCR = true;
+                this.submit();
+                return;
+            case "enter":
+                if (this.lastWasCR) {
+                    this.lastWasCR = false;
+                    return;
+                }
+                this.insertNewline();
+                return;
+            case "backspace":
+                this.lastWasCR = false;
+                this.backspace();
+                return;
+            case "delete":
+                this.lastWasCR = false;
+                this.deleteForward();
+                return;
+            case "left":
+                this.lastWasCR = false;
+                this.moveLeft();
+                return;
+            case "right":
+                this.lastWasCR = false;
+                this.moveRight();
+                return;
+            case "up":
+                this.lastWasCR = false;
+                this.moveUp();
+                return;
+            case "down":
+                this.lastWasCR = false;
+                this.moveDown();
+                return;
+            case "home":
+                this.lastWasCR = false;
+                this.moveHome();
+                return;
+            case "end":
+                this.lastWasCR = false;
+                this.moveEnd();
+                return;
+            case "pageup":
+                this.lastWasCR = false;
+                this.moveToStart();
+                return;
+            case "pagedown":
+                this.lastWasCR = false;
+                this.moveToEnd();
+                return;
+            case "tab":
+                this.lastWasCR = false;
+                this.tabComplete();
+                return;
+        }
+        if (k?.ctrl) {
+            this.lastWasCR = false;
+            switch (name) {
+                case "c":
+                    this.ctrlC();
+                    return;
+                case "d":
+                    this.ctrlD();
+                    return;
+                case "a":
+                    this.moveHome();
+                    return;
+                case "e":
+                    this.moveEnd();
+                    return;
+                case "u":
+                    this.killToStart();
+                    return;
+                case "k":
+                    this.killToEnd();
+                    return;
+                case "w":
+                    this.killWordBefore();
+                    return;
+                case "l":
+                    this.clearScreen();
+                    return;
+                default:
+                    return;
+            }
+        }
+        if (k?.meta) {
+            this.lastWasCR = false;
+            switch (name) {
+                case "b":
+                    this.moveWordLeft();
+                    return;
+                case "f":
+                    this.moveWordRight();
+                    return;
+                case "d":
+                    this.killWordAfter();
+                    return;
+                default:
+                    return;
+            }
+        }
+        if (str && !/^[\u0000-\u001f\u007f]/.test(str)) {
+            this.lastWasCR = false;
+            this.insertText(str);
+        }
+    }
+    submit() {
+        if (this.questionCb) {
+            const cb = this.questionCb;
+            this.questionCb = null;
+            const answer = this.lines.join("\n").trim();
+            this.commitFrame();
+            this.output.write("\r\n");
+            this.lines = [""];
+            this.row = 0;
+            this.col = 0;
+            this.prevCursorRow = 0;
+            cb(answer);
+            return;
+        }
+        const text = this.lines.join("\n");
+        if (text.trim()) {
+            this.history.push(text);
+            if (this.history.length > this.historySize) {
+                this.history = this.history.slice(-this.historySize);
+            }
+        }
+        this.historyIndex = -1;
+        this.stash = null;
+        this.commitFrame();
+        this.output.write("\r\n");
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        this.prevCursorRow = 0;
+        this.emitLine(text);
+    }
+    /** Move the cursor to the end of the buffer's last visual row so the
+     *  submitted text stays on screen (commit), without erasing the frame. */
+    commitFrame() {
+        const layout = this.layout();
+        const idx = layoutIndexFor(layout, this.row, this.col);
+        const rowsDown = layout.length - 1 - idx;
+        const lastLen = charLen(stripAnsi(layout[layout.length - 1].text));
+        const out = [];
+        if (rowsDown > 0)
+            out.push(`\x1b[${rowsDown}B`);
+        out.push("\r");
+        if (lastLen > 0)
+            out.push(`\x1b[${lastLen}C`);
+        this.output.write(out.join(""));
+    }
+    ctrlC() {
+        this.lines = [""];
+        this.row = 0;
+        this.col = 0;
+        this.prevCursorRow = 0;
+        this.render();
+        process.emit("SIGINT");
+    }
+    ctrlD() {
+        if (this.lines.length === 1 && this.lines[0] === "") {
+            this.emitClose();
+        }
+        else {
+            this.deleteForward();
+        }
+    }
+    // ---- editing primitives ----
+    currentChars() {
+        return Array.from(this.lines[this.row]);
+    }
+    setCurrentChars(chars) {
+        this.lines[this.row] = chars.join("");
+    }
+    insertText(text) {
+        const sanitized = text.replace(/\r\n/g, "\n").replace(/\r/g, "");
+        const chars = this.currentChars();
+        const t = Array.from(sanitized);
+        chars.splice(this.col, 0, ...t);
+        this.setCurrentChars(chars);
+        this.col += t.length;
+        this.render();
+    }
+    /** Bulk-insert pasted text at the cursor. Splits on newlines so the buffer
+     *  keeps one string per line (instead of embedding literal `\n` chars),
+     *  and renders once — a paste must look like a paste, not like typing. */
+    insertPaste(text) {
+        const segments = text.split("\n");
+        if (segments.length === 1) {
+            this.insertText(segments[0]);
+            return;
+        }
+        const chars = this.currentChars();
+        const head = chars.slice(0, this.col).join("");
+        const tail = chars.slice(this.col).join("");
+        const lines = [head + segments[0]];
+        for (let i = 1; i < segments.length - 1; i++)
+            lines.push(segments[i]);
+        lines.push(segments[segments.length - 1] + tail);
+        this.lines.splice(this.row, 1, ...lines);
+        this.row += segments.length - 1;
+        this.col = charLen(segments[segments.length - 1]);
+        this.render();
+    }
+    insertNewline() {
+        const chars = this.currentChars();
+        const rest = chars.slice(this.col).join("");
+        this.setCurrentChars(chars.slice(0, this.col));
+        this.lines.splice(this.row + 1, 0, rest);
+        this.row++;
+        this.col = 0;
+        this.render();
+    }
+    backspace() {
+        const chars = this.currentChars();
+        if (this.col > 0) {
+            chars.splice(this.col - 1, 1);
+            this.setCurrentChars(chars);
+            this.col--;
+        }
+        else if (this.row > 0) {
+            const prevLen = charLen(this.lines[this.row - 1]);
+            this.lines[this.row - 1] = this.lines[this.row - 1] + this.lines[this.row];
+            this.lines.splice(this.row, 1);
+            this.row--;
+            this.col = prevLen;
+        }
+        this.render();
+    }
+    deleteForward() {
+        const chars = this.currentChars();
+        if (this.col < chars.length) {
+            chars.splice(this.col, 1);
+            this.setCurrentChars(chars);
+        }
+        else if (this.row < this.lines.length - 1) {
+            this.lines[this.row] = this.lines[this.row] + this.lines[this.row + 1];
+            this.lines.splice(this.row + 1, 1);
+        }
+        this.render();
+    }
+    killToStart() {
+        const chars = this.currentChars();
+        this.setCurrentChars(chars.slice(this.col));
+        this.col = 0;
+        this.render();
+    }
+    killToEnd() {
+        const chars = this.currentChars();
+        this.setCurrentChars(chars.slice(0, this.col));
+        this.render();
+    }
+    killWordBefore() {
+        const chars = this.currentChars();
+        let i = this.col;
+        while (i > 0 && /\s/.test(chars[i - 1]))
+            i--;
+        while (i > 0 && !/\s/.test(chars[i - 1]))
+            i--;
+        chars.splice(i, this.col - i);
+        this.setCurrentChars(chars);
+        this.col = i;
+        this.render();
+    }
+    killWordAfter() {
+        const chars = this.currentChars();
+        const n = chars.length;
+        let i = this.col;
+        while (i < n && /\s/.test(chars[i]))
+            i++;
+        while (i < n && !/\s/.test(chars[i]))
+            i++;
+        chars.splice(this.col, i - this.col);
+        this.setCurrentChars(chars);
+        this.render();
+    }
+    // ---- navigation ----
+    moveLeft() {
+        if (this.col > 0) {
+            this.col--;
+        }
+        else if (this.row > 0) {
+            this.row--;
+            this.col = charLen(this.lines[this.row]);
+        }
+        this.render();
+    }
+    moveRight() {
+        if (this.col < charLen(this.lines[this.row])) {
+            this.col++;
+        }
+        else if (this.row < this.lines.length - 1) {
+            this.row++;
+            this.col = 0;
+        }
+        this.render();
+    }
+    moveUp() {
+        const layout = this.layout();
+        const idx = layoutIndexFor(layout, this.row, this.col);
+        const vcol = visualColAt(layout, idx, this.col);
+        if (idx > 0) {
+            const target = layout[idx - 1];
+            this.row = target.bufRow;
+            this.col = charOffsetFor(layout, idx - 1, vcol);
+            this.render();
+        }
+        else {
+            this.historyPrev();
+        }
+    }
+    moveDown() {
+        const layout = this.layout();
+        const idx = layoutIndexFor(layout, this.row, this.col);
+        const vcol = visualColAt(layout, idx, this.col);
+        if (idx < layout.length - 1) {
+            const target = layout[idx + 1];
+            this.row = target.bufRow;
+            this.col = charOffsetFor(layout, idx + 1, vcol);
+            this.render();
+        }
+        else {
+            this.historyNext();
+        }
+    }
+    moveHome() {
+        this.col = 0;
+        this.render();
+    }
+    moveEnd() {
+        this.col = charLen(this.lines[this.row]);
+        this.render();
+    }
+    moveToStart() {
+        this.row = 0;
+        this.col = 0;
+        this.render();
+    }
+    moveToEnd() {
+        this.row = this.lines.length - 1;
+        this.col = charLen(this.lines[this.row]);
+        this.render();
+    }
+    moveWordLeft() {
+        const chars = this.currentChars();
+        let i = this.col;
+        while (i > 0 && /\s/.test(chars[i - 1]))
+            i--;
+        while (i > 0 && !/\s/.test(chars[i - 1]))
+            i--;
+        this.col = i;
+        this.render();
+    }
+    moveWordRight() {
+        const chars = this.currentChars();
+        const n = chars.length;
+        let i = this.col;
+        while (i < n && !/\s/.test(chars[i]))
+            i++;
+        while (i < n && /\s/.test(chars[i]))
+            i++;
+        this.col = i;
+        this.render();
+    }
+    historyPrev() {
+        if (this.history.length === 0)
+            return;
+        if (this.historyIndex === -1) {
+            this.stash = {
+                lines: this.lines.slice(),
+                row: this.row,
+                col: this.col,
+            };
+            this.historyIndex = 0;
+        }
+        else if (this.historyIndex < this.history.length - 1) {
+            this.historyIndex++;
+        }
+        else {
+            return;
+        }
+        this.applyHistoryEntry();
+    }
+    historyNext() {
+        if (this.historyIndex === -1)
+            return;
+        if (this.historyIndex > 0) {
+            this.historyIndex--;
+            this.applyHistoryEntry();
+        }
+        else if (this.stash) {
+            this.lines = this.stash.lines.slice();
+            this.row = this.stash.row;
+            this.col = this.stash.col;
+            this.historyIndex = -1;
+            this.stash = null;
+            this.render();
+        }
+    }
+    applyHistoryEntry() {
+        const entry = this.history[this.history.length - 1 - this.historyIndex];
+        this.lines = entry.split("\n");
+        if (this.lines.length === 0)
+            this.lines = [""];
+        this.row = this.lines.length - 1;
+        this.col = charLen(this.lines[this.row]);
+        this.render();
+    }
+    // ---- completion / misc ----
+    tabComplete() {
+        if (!this.completer)
+            return;
+        const line = this.lines[this.row];
+        const [matches, partial] = this.completer(line);
+        if (matches.length === 0) {
+            this.output.write("\x07");
+            return;
+        }
+        if (matches.length === 1) {
+            const from = line.lastIndexOf(partial);
+            const head = line.slice(0, from);
+            const tail = line.slice(from + partial.length);
+            this.lines[this.row] = head + matches[0] + tail;
+            this.col = charLen(head) + charLen(matches[0]);
+            this.render();
+            return;
+        }
+        const lines = matches.map((m) => "  " + m);
+        this.output.write("\r\n" + lines.join("\r\n") + "\r\n");
+        this.output.write(`\x1b[${lines.length + 1}A`);
+        this.render();
+    }
+    clearScreen() {
+        this.output.write("\x1b[2J\x1b[H");
+        this.prevCursorRow = 0;
+        this.render();
+    }
+    // ---- rendering ----
+    columns() {
+        return this.output.columns || 80;
+    }
+    layout() {
+        return buildLayout(this.lines, this.columns());
+    }
+    render() {
+        if (!this.input.isTTY || this.isDone)
+            return;
+        const layout = this.layout();
+        const promptWidth = stringWidth(stripAnsi(this.promptStr));
+        const idx = layoutIndexFor(layout, this.row, this.col);
+        const vcol = visualColAt(layout, idx, this.col);
+        const rowsAfter = layout.length - idx - 1;
+        const ccol = (idx === 0 ? promptWidth : 0) + vcol;
+        const out = [];
+        // Move back up to the frame's first row before redrawing. Without this,
+        // a redraw that starts on a middle/bottom row (e.g. typing on line 2 of
+        // a multi-line buffer) writes the whole frame one row too low and leaves
+        // the previous frame's top line stale on screen — the user sees every
+        // line duplicated.
+        if (this.prevCursorRow > 0)
+            out.push(`\x1b[${this.prevCursorRow}A`);
+        out.push("\r");
+        for (let i = 0; i < layout.length; i++) {
+            out.push("\x1b[2K");
+            if (i === 0)
+                out.push(this.promptStr);
+            out.push(layout[i].text);
+            if (i < layout.length - 1)
+                out.push("\r\n");
+        }
+        out.push("\x1b[J");
+        if (rowsAfter > 0)
+            out.push(`\x1b[${rowsAfter}A`);
+        out.push("\r");
+        if (ccol > 0)
+            out.push(`\x1b[${ccol}C`);
+        this.prevCursorRow = idx;
+        this.output.write(out.join(""));
+    }
+    enableTerminalProtocols() {
+        this.output.write("\x1b[?2004h");
+        this.output.write("\x1b[>1u");
+    }
+    disableTerminalProtocols() {
+        this.output.write("\x1b[?2004l");
+        this.output.write("\x1b[<u");
+    }
+    emitLine(line) {
+        this.listeners.line?.(line);
+    }
+    emitClose() {
+        this.listeners.close?.();
+    }
+}