@sheepbun/yips 0.1.1

package/dist/ui/downloader/downloader-ui.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDownloaderLines = renderDownloaderLines;
+const colors_1 = require("#ui/colors");
+const TAB_INACTIVE = { r: 0x88, g: 0x88, b: 0x88 };
+const BLACK = { r: 0x00, g: 0x00, b: 0x00 };
+const FOCUS_ACCENT_BG = { r: 0xff, g: 0xcc, b: 0xff };
+const DOWNLOADER_MODEL_BODY_ROWS = 10;
+const DOWNLOADER_FILE_BODY_ROWS = 10;
+const ANSI_BOLD_ON = "\u001b[1m";
+const ANSI_BOLD_OFF = "\u001b[22m";
+function charLength(text) {
+    return Array.from((0, colors_1.stripAnsi)(text)).length;
+}
+function fitRight(text, width) {
+    const chars = Array.from(text);
+    if (chars.length <= width) {
+        return text;
+    }
+    return chars.slice(chars.length - width).join("");
+}
+function fitLeft(text, width) {
+    const chars = Array.from(text);
+    if (chars.length <= width) {
+        return text;
+    }
+    if (width <= 3) {
+        return chars.slice(0, width).join("");
+    }
+    return `${chars.slice(0, width - 3).join("")}...`;
+}
+function formatCount(value) {
+    if (value >= 1_000_000) {
+        return `${(value / 1_000_000).toFixed(1)}M`;
+    }
+    if (value >= 1_000) {
+        return `${(value / 1_000).toFixed(1)}k`;
+    }
+    return String(value);
+}
+function formatSize(bytes) {
+    if (bytes === null || bytes <= 0) {
+        return "?";
+    }
+    const gib = bytes / (1024 * 1024 * 1024);
+    return `${gib.toFixed(1)}G`;
+}
+function tabText(tab, activeTab) {
+    const label = ` ${tab} `;
+    if (tab === activeTab) {
+        return `${ANSI_BOLD_ON}${(0, colors_1.horizontalGradientBackground)(label, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, BLACK)}${ANSI_BOLD_OFF}`;
+    }
+    return `${ANSI_BOLD_ON}${(0, colors_1.colorText)(label, TAB_INACTIVE)}${ANSI_BOLD_OFF}`;
+}
+function makeBorderTop(width) {
+    if (width <= 1)
+        return "╭";
+    const prefix = "╭─── ";
+    const titleBrand = "Yips";
+    const titleDetail = " Model Downloader";
+    const titleTail = " ";
+    const prefixLen = charLength(prefix);
+    const titleBrandLen = charLength(titleBrand);
+    const titleDetailLen = charLength(titleDetail);
+    const titleTailLen = charLength(titleTail);
+    const plainTitleLen = prefixLen + titleBrandLen + titleDetailLen + titleTailLen;
+    const fill = "─".repeat(Math.max(0, width - plainTitleLen - 1));
+    const fillOffset = prefixLen + titleBrandLen + titleDetailLen + titleTailLen;
+    const cornerOffset = width - 1;
+    return `${(0, colors_1.horizontalGradientAtOffset)(prefix, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, 0, width)}${ANSI_BOLD_ON}${(0, colors_1.horizontalGradient)(titleBrand, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}${(0, colors_1.colorText)(titleDetail, colors_1.GRADIENT_BLUE)}${ANSI_BOLD_OFF}${(0, colors_1.horizontalGradientAtOffset)(titleTail, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, prefixLen + titleBrandLen + titleDetailLen, width)}${(0, colors_1.horizontalGradientAtOffset)(fill, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, fillOffset, width)}${(0, colors_1.horizontalGradientAtOffset)("╮", colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, cornerOffset, width)}`;
+}
+function makeBorderBottom(width) {
+    if (width <= 1)
+        return "╰";
+    const mid = "─".repeat(Math.max(0, width - 2));
+    return `${(0, colors_1.colorText)("╰", colors_1.GRADIENT_PINK)}${(0, colors_1.horizontalGradient)(mid, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW)}${(0, colors_1.colorText)("╯", colors_1.GRADIENT_YELLOW)}`;
+}
+function lineWithBorders(inner, innerWidth) {
+    let fitted = inner;
+    if (charLength(fitted) > innerWidth) {
+        fitted = fitLeft((0, colors_1.stripAnsi)(inner), innerWidth);
+    }
+    const padding = " ".repeat(Math.max(0, innerWidth - charLength(fitted)));
+    return `${(0, colors_1.colorText)("│", colors_1.GRADIENT_PINK)}${fitted}${padding}${(0, colors_1.colorText)("│", colors_1.GRADIENT_YELLOW)}`;
+}
+function composeSplitFooter(left, right, innerWidth) {
+    const leftLen = charLength(left);
+    const rightLen = charLength(right);
+    if (leftLen + rightLen + 1 > innerWidth) {
+        return `${left} ${fitRight(right, Math.max(1, innerWidth - leftLen - 1))}`;
+    }
+    const gap = " ".repeat(Math.max(1, innerWidth - leftLen - rightLen));
+    return `${left}${gap}${right}`;
+}
+function highlightedRow(row) {
+    const chars = Array.from(row);
+    if (chars.length === 0)
+        return row;
+    const first = (0, colors_1.bgColorText)(chars[0] ?? "", FOCUS_ACCENT_BG, BLACK);
+    const rest = chars.slice(1).join("");
+    if (rest.length === 0) {
+        return first;
+    }
+    return `${first}${(0, colors_1.horizontalGradientBackground)(rest, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW, BLACK)}`;
+}
+function buildModelRows(state, contentWidth, rowCount) {
+    const rows = [];
+    if (state.models.length === 0) {
+        rows.push((0, colors_1.colorText)("No compatible models found for current RAM+VRAM.", colors_1.WARNING_YELLOW));
+        return rows;
+    }
+    const dlWidth = 9;
+    const likesWidth = 6;
+    const sizeWidth = 5;
+    const dateWidth = 10;
+    const staticWidth = 2 + 3 + dlWidth + 3 + likesWidth + 3 + sizeWidth + 3 + dateWidth;
+    const modelWidth = Math.max(8, contentWidth - staticWidth);
+    const header = `  ${"Model".padEnd(modelWidth, " ")} | ${"Downloads".padStart(dlWidth, " ")} | ${"Likes".padStart(likesWidth, " ")} | ${"Size".padStart(sizeWidth, " ")} | ${"Updated".padStart(dateWidth, " ")}`;
+    rows.push((0, colors_1.horizontalGradient)(header, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW));
+    const visibleRowCount = Math.max(0, rowCount - 1);
+    const start = state.modelScrollOffset;
+    const end = Math.min(state.models.length, start + visibleRowCount);
+    for (let index = start; index < end; index++) {
+        const model = state.models[index];
+        if (!model)
+            continue;
+        const prefix = index === state.selectedModelIndex ? ">" : " ";
+        const modelCell = fitLeft(model.id, modelWidth).padEnd(modelWidth, " ");
+        const downloadsCell = `${formatCount(model.downloads)}↓`.padStart(dlWidth, " ");
+        const likesCell = `${formatCount(model.likes)}♥`.padStart(likesWidth, " ");
+        const sizeCell = formatSize(model.sizeBytes).padStart(sizeWidth, " ");
+        const dateCell = model.lastModified.slice(0, 10).padStart(dateWidth, " ");
+        const row = `${prefix} ${modelCell} | ${downloadsCell} | ${likesCell} | ${sizeCell} | ${dateCell}`;
+        rows.push(index === state.selectedModelIndex ? highlightedRow(row) : row);
+    }
+    return rows;
+}
+function toFileFitLabel(state, file) {
+    if (!file.canRun) {
+        return file.reason;
+    }
+    if (file.sizeBytes === null || file.sizeBytes <= 0) {
+        return file.reason;
+    }
+    if (!Number.isFinite(state.vramGb) || state.vramGb <= 0) {
+        return file.reason;
+    }
+    const vramBytes = state.vramGb * 1024 ** 3;
+    return file.sizeBytes <= vramBytes ? "Fits on GPU" : "Fits on GPU+CPU";
+}
+function buildFileRows(state, contentWidth, rowCount) {
+    const rows = [];
+    if (state.files.length === 0) {
+        rows.push((0, colors_1.colorText)("No GGUF files found for this model.", colors_1.WARNING_YELLOW));
+        return rows;
+    }
+    const quantWidth = 21;
+    const sizeWidth = 5;
+    const fitWidth = 16;
+    const staticWidth = 2 + 3 + quantWidth + 3 + sizeWidth + 3 + fitWidth;
+    const fileWidth = Math.max(8, contentWidth - staticWidth);
+    const header = `  ${"File".padEnd(fileWidth, " ")} | ${"Quant".padEnd(quantWidth, " ")} | ${"Size".padStart(sizeWidth, " ")} | ${"Fit".padEnd(fitWidth, " ")}`;
+    rows.push((0, colors_1.horizontalGradient)(header, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW));
+    const visibleRowCount = Math.max(0, rowCount - 1);
+    const start = state.fileScrollOffset;
+    const end = Math.min(state.files.length, start + visibleRowCount);
+    for (let index = start; index < end; index++) {
+        const file = state.files[index];
+        if (!file)
+            continue;
+        const prefix = index === state.selectedFileIndex ? ">" : " ";
+        const basename = file.path.includes("/")
+            ? (file.path.split("/").pop() ?? file.path)
+            : file.path;
+        const fileCell = fitLeft(basename, fileWidth).padEnd(fileWidth, " ");
+        const quantCell = fitLeft(file.quant, quantWidth).padEnd(quantWidth, " ");
+        const sizeCell = formatSize(file.sizeBytes).padStart(sizeWidth, " ");
+        const fitCell = fitLeft(toFileFitLabel(state, file), fitWidth).padEnd(fitWidth, " ");
+        const row = `${prefix} ${fileCell} | ${quantCell} | ${sizeCell} | ${fitCell}`;
+        if (index === state.selectedFileIndex) {
+            rows.push(highlightedRow(row));
+            continue;
+        }
+        rows.push((0, colors_1.colorText)(row, file.canRun ? colors_1.SUCCESS_GREEN : colors_1.ERROR_RED));
+    }
+    return rows;
+}
+function fillRows(rows, rowCount) {
+    if (rows.length >= rowCount) {
+        return rows.slice(0, rowCount);
+    }
+    return [...rows, ...new Array(rowCount - rows.length).fill("")];
+}
+function buildProgressBar(innerWidth, bytesDownloaded, totalBytes) {
+    if (totalBytes === null || totalBytes <= 0) {
+        return "Progress: downloading...";
+    }
+    const suffix = ` ${((bytesDownloaded / totalBytes) * 100).toFixed(1)}%`;
+    const barWidth = Math.max(1, innerWidth - suffix.length - 2);
+    const progress = Math.max(0, Math.min(1, bytesDownloaded / totalBytes));
+    const filled = Math.round(barWidth * progress);
+    const empty = Math.max(0, barWidth - filled);
+    return `[${"█".repeat(filled)}${"░".repeat(empty)}]${suffix}`;
+}
+function buildDownloadingRows(state, innerWidth) {
+    if (!state.download) {
+        return [`Loading: ${state.loadingMessage}`];
+    }
+    const filename = state.download.filename.includes("/")
+        ? (state.download.filename.split("/").pop() ?? state.download.filename)
+        : state.download.filename;
+    const rows = [];
+    rows.push((0, colors_1.colorText)(`Downloading ${fitLeft(filename, Math.max(1, innerWidth - 12))}`, colors_1.GRADIENT_BLUE));
+    rows.push((0, colors_1.colorText)(buildProgressBar(innerWidth, state.download.bytesDownloaded, state.download.totalBytes), colors_1.SUCCESS_GREEN));
+    return rows;
+}
+function buildCancelConfirmRows(innerWidth) {
+    const message = fitLeft("Cancel download and delete partial file?", Math.max(1, innerWidth));
+    return [(0, colors_1.colorText)(message, colors_1.WARNING_YELLOW), ""];
+}
+function renderDownloaderLines(options) {
+    const width = Math.max(20, options.width);
+    const state = options.state;
+    const innerWidth = Math.max(1, width - 2);
+    const rows = [];
+    rows.push(makeBorderTop(width));
+    if (state.phase !== "downloading") {
+        const tabs = [
+            tabText("Most Downloaded", state.tab),
+            tabText("Top Rated", state.tab),
+            tabText("Newest", state.tab)
+        ].join(" ");
+        const memText = `RAM: ${state.ramGb.toFixed(1)}GB | VRAM: ${state.vramGb.toFixed(1)}GB | Disk: ${state.diskFreeGb.toFixed(1)}GB`;
+        const memWidth = Math.min(charLength(memText), Math.max(24, innerWidth - 10));
+        const tabsWidth = Math.max(1, innerWidth - memWidth - 1);
+        let tabsCell = tabs;
+        if (charLength(tabsCell) > tabsWidth) {
+            tabsCell = fitLeft(" Most Downloaded   Top Rated   Newest ", tabsWidth);
+        }
+        const tabsPadding = " ".repeat(Math.max(0, tabsWidth - charLength(tabsCell)));
+        rows.push(lineWithBorders(`${tabsCell}${tabsPadding} ${fitRight(memText, memWidth)}`, innerWidth));
+    }
+    let bodyRows = [];
+    if (state.view === "models") {
+        if (state.phase === "loading-models") {
+            bodyRows = fillRows([`Loading: ${state.loadingMessage}`], DOWNLOADER_MODEL_BODY_ROWS);
+        }
+        else if (state.phase === "error" && state.errorMessage.length > 0) {
+            bodyRows = fillRows([`Error: ${state.errorMessage}`], DOWNLOADER_MODEL_BODY_ROWS);
+        }
+        else {
+            bodyRows = fillRows(buildModelRows(state, innerWidth, DOWNLOADER_MODEL_BODY_ROWS), DOWNLOADER_MODEL_BODY_ROWS);
+        }
+    }
+    else if (state.phase === "downloading") {
+        bodyRows = state.cancelConfirmOpen
+            ? buildCancelConfirmRows(innerWidth)
+            : buildDownloadingRows(state, innerWidth);
+    }
+    else if (state.phase === "loading-files") {
+        bodyRows = fillRows([`Loading: ${state.loadingMessage}`], DOWNLOADER_FILE_BODY_ROWS);
+    }
+    else if (state.phase === "error" && state.errorMessage.length > 0) {
+        bodyRows = fillRows([`Error: ${state.errorMessage}`], DOWNLOADER_FILE_BODY_ROWS);
+    }
+    else {
+        const fileRows = [
+            (0, colors_1.colorText)(`Files for ${fitLeft(state.selectedRepoId, Math.max(1, innerWidth - 10))}`, colors_1.GRADIENT_BLUE),
+            ...buildFileRows(state, innerWidth, DOWNLOADER_FILE_BODY_ROWS - 1)
+        ];
+        bodyRows = fillRows(fileRows, DOWNLOADER_FILE_BODY_ROWS);
+    }
+    rows.push(...bodyRows.map((row) => lineWithBorders(row, innerWidth)));
+    if (state.phase === "downloading") {
+        const status = state.download?.statusText ?? "Downloading...";
+        const left = state.cancelConfirmOpen ? "[Enter] Yes  [Esc] No" : "[Esc] Cancel";
+        const statusWidth = Math.max(1, innerWidth - Array.from(left).length - 1);
+        const footer = composeSplitFooter(left, fitRight(status, statusWidth), innerWidth);
+        rows.push(lineWithBorders((0, colors_1.horizontalGradient)(footer, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW), innerWidth));
+    }
+    else {
+        const footer = state.view === "models"
+            ? "[Enter] Select  [↑/↓] Move  [←/→] Sort  [Esc] Close"
+            : "[Enter] Download  [↑/↓] Move  [Esc] Back";
+        rows.push(lineWithBorders((0, colors_1.horizontalGradient)(footer, colors_1.GRADIENT_PINK, colors_1.GRADIENT_YELLOW), innerWidth));
+    }
+    rows.push(makeBorderBottom(width));
+    return rows;
+}

package/dist/ui/input/input-engine.js

@@ -0,0 +1,250 @@
+"use strict";
+/** Raw-stdin input parser for deterministic prompt editing actions. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputEngine = void 0;
+exports.parseCsiSequence = parseCsiSequence;
+const node_string_decoder_1 = require("node:string_decoder");
+function parseInteger(value) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) ? parsed : null;
+}
+function isEnterKeyCode(code) {
+    return code === 1 || code === 10 || code === 13 || code === 57414;
+}
+function toEnterAction(modifier) {
+    return modifier > 1 ? { type: "newline" } : { type: "submit" };
+}
+function parseEnterActionFromCsiBody(body, final) {
+    if (final === "u" || final === "~" || final === "M") {
+        const keyOnly = body.match(/^(\d+)$/);
+        if (keyOnly) {
+            const keyCode = parseInteger(keyOnly[1] ?? "");
+            if (keyCode !== null && isEnterKeyCode(keyCode)) {
+                return { type: "submit" };
+            }
+        }
+        const keyAndModifier = body.match(/^(\d+);(\d+)$/);
+        if (keyAndModifier) {
+            const keyCode = parseInteger(keyAndModifier[1] ?? "");
+            const modifier = parseInteger(keyAndModifier[2] ?? "");
+            if (keyCode !== null && modifier !== null && isEnterKeyCode(keyCode) && modifier >= 1) {
+                return toEnterAction(modifier);
+            }
+        }
+    }
+    if (final === "~") {
+        const legacyModifyOtherKeys = body.match(/^27;(\d+);(\d+)$/);
+        if (legacyModifyOtherKeys) {
+            const first = parseInteger(legacyModifyOtherKeys[1] ?? "");
+            const second = parseInteger(legacyModifyOtherKeys[2] ?? "");
+            if (first === null || second === null) {
+                return null;
+            }
+            if (isEnterKeyCode(first) && second >= 1) {
+                return toEnterAction(second);
+            }
+            if (isEnterKeyCode(second) && first >= 1) {
+                return toEnterAction(first);
+            }
+        }
+    }
+    return null;
+}
+function parseMouseActionFromCsiBody(body, final) {
+    if (final !== "M" && final !== "m") {
+        return null;
+    }
+    if (!body.startsWith("<")) {
+        return null;
+    }
+    const params = body.slice(1).split(";");
+    const buttonCode = parseInteger(params[0] ?? "");
+    if (buttonCode === null) {
+        return null;
+    }
+    // SGR mouse wheel encodes bit 6 for wheel + bit 0 for direction.
+    // Modifier bits may be present (shift/alt/ctrl), so match by bitmask.
+    if ((buttonCode & 0x40) !== 0) {
+        return (buttonCode & 0x01) === 0
+            ? { type: "scroll-line-up" }
+            : { type: "scroll-line-down" };
+    }
+    return null;
+}
+function parseCsiSequence(sequence) {
+    if (!sequence.startsWith("\x1b[")) {
+        return null;
+    }
+    if (sequence.length < 3) {
+        return null;
+    }
+    const final = sequence[sequence.length - 1] ?? "";
+    const body = sequence.slice(2, -1);
+    const enterAction = parseEnterActionFromCsiBody(body, final);
+    if (enterAction) {
+        return enterAction;
+    }
+    const mouseAction = parseMouseActionFromCsiBody(body, final);
+    if (mouseAction) {
+        return mouseAction;
+    }
+    if (final === "A")
+        return { type: "move-up" };
+    if (final === "B")
+        return { type: "move-down" };
+    if (final === "C")
+        return { type: "move-right" };
+    if (final === "D")
+        return { type: "move-left" };
+    if (final === "H")
+        return { type: "home" };
+    if (final === "F")
+        return { type: "end" };
+    if (final === "Z")
+        return { type: "tab" };
+    if (final === "~") {
+        const firstParam = body.split(";")[0] ?? "";
+        if (firstParam === "1" || firstParam === "7")
+            return { type: "home" };
+        if (firstParam === "4" || firstParam === "8")
+            return { type: "end" };
+        if (firstParam === "3")
+            return { type: "delete" };
+        if (firstParam === "5")
+            return { type: "scroll-page-up" };
+        if (firstParam === "6")
+            return { type: "scroll-page-down" };
+    }
+    return null;
+}
+function isCsiFinalByte(byte) {
+    return byte >= 0x40 && byte <= 0x7e;
+}
+function parseEscapeSequence(buffer, startIndex) {
+    if (startIndex + 1 >= buffer.length) {
+        return null;
+    }
+    const second = buffer[startIndex + 1] ?? 0;
+    if (second === 0x5b) {
+        let index = startIndex + 2;
+        while (index < buffer.length) {
+            const byte = buffer[index] ?? 0;
+            if (isCsiFinalByte(byte)) {
+                const sequence = buffer.subarray(startIndex, index + 1).toString("latin1");
+                return { action: parseCsiSequence(sequence), nextIndex: index + 1 };
+            }
+            index += 1;
+        }
+        return null;
+    }
+    if (second === 0x4f) {
+        if (startIndex + 2 >= buffer.length) {
+            return null;
+        }
+        const third = buffer[startIndex + 2] ?? 0;
+        if (third === 0x4d) {
+            return { action: { type: "submit" }, nextIndex: startIndex + 3 };
+        }
+        return { action: null, nextIndex: startIndex + 3 };
+    }
+    if (second === 0x0d || second === 0x0a) {
+        return { action: { type: "newline" }, nextIndex: startIndex + 2 };
+    }
+    return { action: null, nextIndex: startIndex + 2 };
+}
+class InputEngine {
+    pending = Buffer.alloc(0);
+    decoder = new node_string_decoder_1.StringDecoder("utf8");
+    reset() {
+        this.pending = Buffer.alloc(0);
+        this.decoder.end();
+    }
+    pushChunk(chunk) {
+        const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "latin1");
+        if (incoming.length === 0) {
+            return [];
+        }
+        this.pending =
+            this.pending.length > 0 ? Buffer.concat([this.pending, incoming]) : Buffer.from(incoming);
+        const actions = [];
+        let index = 0;
+        let textStart = null;
+        const flushText = (endIndex) => {
+            if (textStart === null || endIndex <= textStart) {
+                textStart = null;
+                return;
+            }
+            const text = this.decoder.write(this.pending.subarray(textStart, endIndex));
+            if (text.length > 0) {
+                actions.push({ type: "insert", text });
+            }
+            textStart = null;
+        };
+        while (index < this.pending.length) {
+            const byte = this.pending[index] ?? 0;
+            if (byte === 0x1b) {
+                flushText(index);
+                const parsed = parseEscapeSequence(this.pending, index);
+                if (!parsed) {
+                    break;
+                }
+                if (parsed.action) {
+                    actions.push(parsed.action);
+                }
+                index = parsed.nextIndex;
+                continue;
+            }
+            if (byte === 0x03) {
+                flushText(index);
+                actions.push({ type: "cancel" });
+                index += 1;
+                continue;
+            }
+            if (byte === 0x7f || byte === 0x08) {
+                flushText(index);
+                actions.push({ type: "backspace" });
+                index += 1;
+                continue;
+            }
+            if (byte === 0x0d) {
+                flushText(index);
+                actions.push({ type: "submit" });
+                index += 1;
+                if (this.pending[index] === 0x0a) {
+                    index += 1;
+                }
+                continue;
+            }
+            if (byte === 0x0a) {
+                flushText(index);
+                actions.push({ type: "newline" });
+                index += 1;
+                continue;
+            }
+            if (byte === 0x09) {
+                flushText(index);
+                actions.push({ type: "tab" });
+                index += 1;
+                continue;
+            }
+            if (byte < 0x20) {
+                flushText(index);
+                index += 1;
+                continue;
+            }
+            if (textStart === null) {
+                textStart = index;
+            }
+            index += 1;
+        }
+        // Treat lone ESC as cancel (close modal/back) when it is not part of a CSI sequence.
+        if (index < this.pending.length && this.pending[index] === 0x1b && this.pending.length - index === 1) {
+            actions.push({ type: "cancel" });
+            index += 1;
+        }
+        flushText(index);
+        this.pending = this.pending.subarray(index);
+        return actions;
+    }
+}
+exports.InputEngine = InputEngine;

package/dist/ui/input/tui-input-routing.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideConfirmationAction = decideConfirmationAction;
+exports.routeVtInput = routeVtInput;
+function decideConfirmationAction(actions) {
+    for (const action of actions) {
+        if (action.type === "cancel") {
+            return "deny";
+        }
+        if (action.type === "submit") {
+            return "approve";
+        }
+        if (action.type === "insert") {
+            const normalized = action.text.trim().toLowerCase();
+            if (normalized === "y" || normalized === "yes") {
+                return "approve";
+            }
+            if (normalized === "n" || normalized === "no") {
+                return "deny";
+            }
+        }
+    }
+    return null;
+}
+function routeVtInput(sequence, escapePending) {
+    const bytes = Buffer.from(sequence, "latin1");
+    if (bytes.includes(0x11)) {
+        return {
+            exitToChat: true,
+            nextEscapePending: false,
+            passthrough: null
+        };
+    }
+    if (sequence === "\u001b") {
+        if (escapePending) {
+            return {
+                exitToChat: true,
+                nextEscapePending: false,
+                passthrough: null
+            };
+        }
+        return {
+            exitToChat: false,
+            nextEscapePending: true,
+            passthrough: null
+        };
+    }
+    return {
+        exitToChat: false,
+        nextEscapePending: false,
+        passthrough: sequence
+    };
+}