@giovannijecha/jecode 0.1.5-rc.2

package/dist/tui/components/tool.js

@@ -0,0 +1,85 @@
+import { blank, row } from "../../ui/render.js";
+const PAD = 1;
+const PREVIEW_ROWS = 10;
+export function renderTool(block, width, pal) {
+    const ground = toolGround(block.tone, pal);
+    const all = block.body ?? [];
+    const shown = block.expanded === true ? all : all.slice(0, PREVIEW_ROWS);
+    const remaining = all.length - shown.length;
+    const rows = [
+        "",
+        blank(width, ground),
+        row(width, [
+            { text: block.name, fg: pal.ink.bright, bold: true },
+            ...(block.target === "" ? [] : [{ text: ` ${block.target}`, fg: pal.accent }]),
+        ], [], ground, PAD),
+    ];
+    if (shown.length > 0) {
+        rows.push(blank(width, ground));
+        rows.push(...shown.map((detail) => renderDetail(detail, block.tone, width, ground, pal)));
+    }
+    if (remaining > 0) {
+        rows.push(row(width, [{ text: `… ${remaining} more lines · ctrl+o expand`, fg: pal.ink.muted }], [], ground, PAD));
+    }
+    if (block.right !== "") {
+        rows.push(row(width, [{ text: resultLabel(block.right, block.tone), fg: statusInk(block.tone, pal) }], [], ground, PAD));
+    }
+    rows.push(blank(width, ground));
+    return rows;
+}
+function renderDetail(detail, tone, width, ground, pal) {
+    if (detail.kind === "out") {
+        const fg = tone === "fail" || failureLine(detail.text) ? pal.ink.removed : pal.ink.muted;
+        return row(width, [{ text: detail.text === "" ? " " : detail.text, fg }], [], ground, PAD);
+    }
+    if (detail.kind === "gap") {
+        return row(width, [{ text: `     ${detail.text}`, fg: pal.ink.muted }], [], ground, PAD);
+    }
+    const number = detail.kind === "add" ? detail.newLine : detail.oldLine;
+    const prefix = `${detail.kind === "add" ? "+" : detail.kind === "del" ? "-" : " "}${String(number ?? "").padStart(3)} `;
+    const fg = detail.kind === "add"
+        ? pal.ink.added
+        : detail.kind === "del"
+            ? pal.ink.removed
+            : pal.ink.muted;
+    return row(width, [{ text: prefix, fg }, ...emphasized(detail.text, detail.emphasis, fg)], [], ground, PAD);
+}
+function emphasized(text, emphasis, fg) {
+    if (emphasis === undefined || emphasis.length <= 0)
+        return [{ text, fg }];
+    const start = Math.max(0, Math.min(text.length, emphasis.start));
+    const end = Math.max(start, Math.min(text.length, start + emphasis.length));
+    return [
+        ...(start === 0 ? [] : [{ text: text.slice(0, start), fg }]),
+        { text: text.slice(start, end), fg, inverse: true },
+        ...(end === text.length ? [] : [{ text: text.slice(end), fg }]),
+    ];
+}
+function toolGround(tone, pal) {
+    if (tone === "ok")
+        return pal.surface.added;
+    if (tone === "fail")
+        return pal.surface.removed;
+    if (tone === "deny")
+        return pal.surface.attention;
+    return pal.surface.inset;
+}
+function statusInk(tone, pal) {
+    if (tone === "fail")
+        return pal.ink.removed;
+    if (tone === "pending")
+        return pal.ink.attention;
+    return pal.ink.muted;
+}
+function failureLine(line) {
+    return line.startsWith("✖") || line.includes("AssertionError") || /\bfailed\b/i.test(line);
+}
+function resultLabel(result, tone) {
+    if (tone === "pending")
+        return result;
+    const match = /^(.*?)(?:\s*·\s*)?(\d+(?:\.\d+)?(?:ms|s))$/.exec(result);
+    if (match === null)
+        return result;
+    const prefix = (match[1] ?? "").trim();
+    return `${prefix === "" ? "" : `${prefix} · `}Took ${match[2]}`;
+}

package/dist/tui/components/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tui/editor.js

@@ -0,0 +1,105 @@
+// The input line: text and a cursor, plus the edits a terminal user expects.
+//
+// Pure functions over an immutable state — no rendering, no I/O — so the whole
+// line editor is testable without a terminal.
+import { graphemes } from "../ui/width.js";
+export const EMPTY = { text: "", cursor: 0 };
+export function of(text) {
+    return { text, cursor: text.length };
+}
+export function insert(state, chunk) {
+    return {
+        text: state.text.slice(0, state.cursor) + chunk + state.text.slice(state.cursor),
+        cursor: state.cursor + chunk.length,
+    };
+}
+export function backspace(state) {
+    if (state.cursor === 0)
+        return state;
+    const from = before(state.text, state.cursor);
+    return { text: state.text.slice(0, from) + state.text.slice(state.cursor), cursor: from };
+}
+export function del(state) {
+    if (state.cursor >= state.text.length)
+        return state;
+    const to = after(state.text, state.cursor);
+    return { text: state.text.slice(0, state.cursor) + state.text.slice(to), cursor: state.cursor };
+}
+export function left(state) {
+    return state.cursor === 0 ? state : { ...state, cursor: before(state.text, state.cursor) };
+}
+export function right(state) {
+    return state.cursor >= state.text.length
+        ? state
+        : { ...state, cursor: after(state.text, state.cursor) };
+}
+export function home(state) {
+    return { ...state, cursor: 0 };
+}
+export function end(state) {
+    return { ...state, cursor: state.text.length };
+}
+export function wordLeft(state) {
+    return { ...state, cursor: startOfWordBefore(state.text, state.cursor) };
+}
+export function wordRight(state) {
+    return { ...state, cursor: endOfWordAfter(state.text, state.cursor) };
+}
+/** ctrl+w — delete the word behind the cursor. */
+export function killWord(state) {
+    const from = startOfWordBefore(state.text, state.cursor);
+    if (from === state.cursor)
+        return state;
+    return { text: state.text.slice(0, from) + state.text.slice(state.cursor), cursor: from };
+}
+/** ctrl+u — delete everything behind the cursor. */
+export function killToStart(state) {
+    return { text: state.text.slice(state.cursor), cursor: 0 };
+}
+/** ctrl+k — delete everything ahead of the cursor. */
+export function killToEnd(state) {
+    return { text: state.text.slice(0, state.cursor), cursor: state.cursor };
+}
+/**
+ * Cursor motion is by grapheme, never by code unit.
+ *
+ * An emoji is two code units and an accented letter can be two more; stepping
+ * over half of either does not move the cursor one place to the left, it
+ * breaks the string — and a lone surrogate is what the terminal then draws.
+ */
+function before(text, cursor) {
+    let at = 0;
+    for (const cluster of graphemes(text)) {
+        const next = at + cluster.length;
+        if (next >= cursor)
+            return at;
+        at = next;
+    }
+    return at;
+}
+function after(text, cursor) {
+    let at = 0;
+    for (const cluster of graphemes(text)) {
+        const next = at + cluster.length;
+        if (at >= cursor)
+            return next;
+        at = next;
+    }
+    return text.length;
+}
+function startOfWordBefore(text, cursor) {
+    let i = cursor;
+    while (i > 0 && text[i - 1] === " ")
+        i--;
+    while (i > 0 && text[i - 1] !== " ")
+        i--;
+    return i;
+}
+function endOfWordAfter(text, cursor) {
+    let i = cursor;
+    while (i < text.length && text[i] === " ")
+        i++;
+    while (i < text.length && text[i] !== " ")
+        i++;
+    return i;
+}

package/dist/tui/feedback.js

@@ -0,0 +1,74 @@
+// Operational feedback belongs in the footer, not in the conversation.
+const INFO_MS = 2_800;
+const WARN_MS = 4_200;
+const ERROR_MS = 6_000;
+/** Own replacement and expiry without leaking timers into the TUI shell. */
+export function feedbackController(changed) {
+    let current;
+    let timer;
+    const clearTimer = () => {
+        if (timer !== undefined)
+            clearTimeout(timer);
+        timer = undefined;
+    };
+    return {
+        show(feedback) {
+            clearTimer();
+            current = feedback;
+            changed(feedback);
+            if (feedback.timeoutMs === undefined)
+                return;
+            timer = setTimeout(() => {
+                timer = undefined;
+                if (current !== feedback)
+                    return;
+                current = undefined;
+                changed(undefined);
+            }, feedback.timeoutMs);
+        },
+        dismiss() {
+            clearTimer();
+            if (current === undefined)
+                return;
+            current = undefined;
+            changed(undefined);
+        },
+        close() {
+            clearTimer();
+            current = undefined;
+        },
+    };
+}
+/** Turn a command notice into one replaceable message in the footer status channel. */
+export function commandFeedback(block) {
+    if (block.kind !== "notice")
+        return undefined;
+    return {
+        text: block.text,
+        tone: block.tone,
+        timeoutMs: block.tone === "info" ? INFO_MS : block.tone === "warn" ? WARN_MS : ERROR_MS,
+    };
+}
+/** Explain why a model turn cannot start, without exposing configuration internals. */
+export function turnBlocker(session) {
+    const blocked = session.provider.blocked();
+    if (blocked !== undefined && !blocked.startsWith(`${session.provider.keyVar} `)) {
+        return { text: blocked, tone: "error" };
+    }
+    if (blocked !== undefined) {
+        return {
+            text: `${providerName(session.provider.id)} needs an API key · /settings`,
+            tone: "warn",
+        };
+    }
+    if (session.model === "") {
+        return {
+            text: `${providerName(session.provider.id)} needs a model · /models`,
+            tone: "warn",
+        };
+    }
+    return undefined;
+}
+function providerName(id) {
+    return id === "" ? "Provider" : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
+}

package/dist/tui/field.js

@@ -0,0 +1,60 @@
+// Typing one line into the dock, when what is being typed is not a message.
+//
+// The composer already knows how to be a line editor, so this borrows it whole
+// — the same `Editor`, the same keymap — and adds the two things a composer
+// must never do: hide what it holds, and stay on one row however long that is.
+import { row } from "../ui/render.js";
+import { graphemes, textWidth } from "../ui/width.js";
+const DOT = "●";
+const PROMPT = "→ ";
+const LEAD = textWidth(PROMPT);
+export function panel(field, width, pal) {
+    const { ink } = pal;
+    const head = row(width, field.title, field.right === undefined ? [] : [{ text: field.right, fg: ink.muted }]);
+    const view = laid(field, width);
+    const line = row(width, [
+        { text: PROMPT, fg: pal.accent },
+        { text: view.text, fg: ink.bright },
+    ]);
+    const note = field.note === undefined ? [] : [row(width, [{ text: `  ${field.note}`, fg: ink.muted }])];
+    return [head, line, ...note];
+}
+/** Where the caret sits, relative to the unframed field body. */
+export function caret(field, width) {
+    return { row: 1, col: LEAD + laid(field, width).col };
+}
+/**
+ * The visible slice of the line, and where the caret lands inside it.
+ *
+ * A key is longer than most terminals are wide, so the line scrolls under a
+ * fixed window rather than wrapping: an input that grows downwards pushes the
+ * rest of the dock around while it is being pasted into.
+ */
+function laid(field, width) {
+    const inner = Math.max(1, width - LEAD);
+    const all = field.secret ? DOT.repeat(size(field.editor.text)) : field.editor.text;
+    const at = size(field.editor.text.slice(0, field.editor.cursor));
+    // Keep the caret in view, and prefer showing the end of what was typed —
+    // which for a pasted key is the half that says the paste arrived whole.
+    const start = Math.max(0, at - inner + 1);
+    return { text: [...all].slice(start, start + inner).join(""), col: at - start };
+}
+function size(text) {
+    let n = 0;
+    for (const _cluster of graphemes(text))
+        n++;
+    return n;
+}
+/**
+ * The line with its breaks taken out.
+ *
+ * A key is one line. A pasted one usually carries the newline that ended it,
+ * and a field that grows a second row on paste is a field that has already
+ * lost its layout — the break is the end of the paste, never content.
+ */
+export function oneLine(editor) {
+    if (!editor.text.includes("\n"))
+        return editor;
+    const kept = editor.text.slice(0, editor.cursor).replace(/\n/g, "");
+    return { text: editor.text.replace(/\n/g, ""), cursor: kept.length };
+}

package/dist/tui/frame.js

@@ -0,0 +1,33 @@
+// Painting a frame by writing only the rows that changed.
+//
+// The whole frame is recomposed on every render — that is what makes the view
+// a pure function of the state. What must not happen on every render is
+// writing it: a full repaint at streaming speed flickers and floods the pipe.
+// So the painter keeps the last frame and emits the difference.
+import { CSI } from "../ui/render.js";
+import { CURSOR, SYNC, write } from "./screen.js";
+export function painter() {
+    let previous = [];
+    return {
+        paint(rows, cursor) {
+            let out = SYNC.begin + CURSOR.hide;
+            const height = Math.max(rows.length, previous.length);
+            for (let i = 0; i < height; i++) {
+                const next = rows[i] ?? "";
+                if (next === previous[i])
+                    continue;
+                out += `${CSI}${i + 1};1H${CSI}2K${next}`;
+            }
+            if (cursor !== undefined) {
+                out += `${CSI}${cursor.row + 1};${cursor.col + 1}H${CURSOR.show}`;
+            }
+            previous = rows.slice();
+            // One write, so a terminal that ignores the synchronization hint still
+            // gets the frame as a single arrival rather than a row at a time.
+            write(out + SYNC.end);
+        },
+        invalidate() {
+            previous = [];
+        },
+    };
+}

package/dist/tui/input.js

@@ -0,0 +1,52 @@
+// Which key does which edit.
+//
+// Pure transforms over the input line, kept apart from the shell so that the
+// keymap can be read — and changed — without reading the turn machinery.
+import * as edit from "./editor.js";
+import { terminalText } from "../ui/terminal-text.js";
+/** The new line, or undefined when the key is not an editing key. */
+export function applyKey(state, key) {
+    switch (key.name) {
+        case "char":
+        case "paste":
+            // A pasted CR is a line break, not a submit: the shell only submits on a
+            // keypress it saw as enter.
+            return edit.insert(state, terminalText(key.text.replace(/\r\n?/g, "\n"), { multiline: true }));
+        case "newline":
+            return edit.insert(state, "\n");
+        case "backspace":
+            return edit.backspace(state);
+        case "delete":
+            return edit.del(state);
+        case "left":
+            return edit.left(state);
+        case "right":
+            return edit.right(state);
+        case "wordleft":
+            return edit.wordLeft(state);
+        case "wordright":
+            return edit.wordRight(state);
+        case "home":
+            return edit.home(state);
+        case "end":
+            return edit.end(state);
+        default:
+            break;
+    }
+    if (!key.ctrl)
+        return undefined;
+    switch (key.name) {
+        case "a":
+            return edit.home(state);
+        case "e":
+            return edit.end(state);
+        case "u":
+            return edit.killToStart(state);
+        case "k":
+            return edit.killToEnd(state);
+        case "w":
+            return edit.killWord(state);
+        default:
+            return undefined;
+    }
+}

package/dist/tui/keys.js

@@ -0,0 +1,177 @@
+// Raw bytes from a terminal, turned into key events.
+//
+// Two things make this stateful rather than a pure function. An escape
+// sequence can be split across reads, so an incomplete one is held rather than
+// guessed at; and a bracketed paste arrives as a delimited run that must not be
+// interpreted key by key, or a pasted newline submits half the paste.
+const ESC = String.fromCharCode(27);
+const DEL = String.fromCharCode(127);
+const PASTE_START = "[200~";
+const PASTE_END = "[201~";
+// SGR mouse reporting (?1006) rather than the original X10 encoding: the old
+// one packs the coordinates into single bytes and simply stops being able to
+// say where the pointer is past column 223.
+const MOUSE = /^\[<(\d+);(\d+);(\d+)([Mm])/;
+const BUTTONS = ["left", "middle", "right", "none"];
+// Both the normal and the application-cursor forms, because a terminal sends
+// either depending on the mode it thinks it is in.
+const SEQUENCES = {
+    "[A": "up",
+    "[B": "down",
+    "[C": "right",
+    "[D": "left",
+    OA: "up",
+    OB: "down",
+    OC: "right",
+    OD: "left",
+    "[H": "home",
+    "[F": "end",
+    OH: "home",
+    OF: "end",
+    "[1~": "home",
+    "[4~": "end",
+    "[7~": "home",
+    "[8~": "end",
+    "[3~": "delete",
+    "[5~": "pageup",
+    "[6~": "pagedown",
+    "[1;5C": "wordright",
+    "[1;5D": "wordleft",
+    "[Z": "backtab",
+    // alt+enter, which arrives as an escape followed by the return itself. It is
+    // how a multi-line message gets written when enter is what sends one.
+    "\r": "newline",
+};
+const CONTROL = {
+    "\r": "enter",
+    "\n": "enter",
+    "\t": "tab",
+    "\b": "backspace",
+    [DEL]: "backspace",
+};
+export function decoder() {
+    let held = "";
+    let pasting = false;
+    let pasted = "";
+    const drain = (final) => {
+        const keys = [];
+        while (held !== "") {
+            if (pasting) {
+                const end = held.indexOf(ESC + PASTE_END);
+                if (end === -1) {
+                    // Hold back a possible partial terminator rather than pasting it.
+                    const safe = held.length - PASTE_END.length - 1;
+                    if (safe > 0) {
+                        pasted += held.slice(0, safe);
+                        held = held.slice(safe);
+                    }
+                    break;
+                }
+                pasted += held.slice(0, end);
+                held = held.slice(end + PASTE_END.length + 1);
+                pasting = false;
+                keys.push({ name: "paste", text: pasted, ctrl: false });
+                pasted = "";
+                continue;
+            }
+            const ch = held[0];
+            if (ch === ESC) {
+                const rest = held.slice(1);
+                if (rest === "" && !final)
+                    break;
+                if (rest.startsWith(PASTE_START)) {
+                    held = rest.slice(PASTE_START.length);
+                    pasting = true;
+                    continue;
+                }
+                const mouse = MOUSE.exec(rest);
+                if (mouse !== null) {
+                    held = rest.slice(mouse[0].length);
+                    keys.push(pointerKey(mouse));
+                    continue;
+                }
+                const match = matchSequence(rest);
+                if (match !== undefined) {
+                    held = rest.slice(match.length);
+                    keys.push({ name: SEQUENCES[match], text: "", ctrl: false });
+                    continue;
+                }
+                if (!final && couldGrow(rest))
+                    break;
+                held = held.slice(1);
+                keys.push({ name: "escape", text: "", ctrl: false });
+                continue;
+            }
+            const named = CONTROL[ch];
+            if (named !== undefined) {
+                held = held.slice(1);
+                keys.push({ name: named, text: "", ctrl: false });
+                continue;
+            }
+            // C0 controls other than the named ones are ctrl+letter.
+            const code = ch.codePointAt(0) ?? 0;
+            if (code < 0x20) {
+                held = held.slice(1);
+                keys.push({ name: String.fromCharCode(code + 0x60), text: "", ctrl: true });
+                continue;
+            }
+            // Printable runs travel together: an unbracketed paste arrives this way,
+            // and inserting it one character at a time is pure overhead.
+            let end = 1;
+            while (end < held.length) {
+                const next = held[end];
+                if ((next.codePointAt(0) ?? 0) < 0x20 || next === ESC || next === DEL)
+                    break;
+                end++;
+            }
+            keys.push({ name: "char", text: held.slice(0, end), ctrl: false });
+            held = held.slice(end);
+        }
+        return keys;
+    };
+    return {
+        push(chunk) {
+            held += chunk;
+            return drain(false);
+        },
+        flush() {
+            return drain(true);
+        },
+    };
+}
+function matchSequence(rest) {
+    for (const seq of Object.keys(SEQUENCES)) {
+        if (rest.startsWith(seq))
+            return seq;
+    }
+    return undefined;
+}
+/** Whether `rest` is still a viable prefix of something we know. */
+function couldGrow(rest) {
+    if (PASTE_START.startsWith(rest))
+        return true;
+    // A mouse report has no fixed length, so it grows until its final letter.
+    if (/^\[<?\d*;?\d*;?\d*$/.test(rest))
+        return true;
+    return Object.keys(SEQUENCES).some((seq) => seq.startsWith(rest));
+}
+function pointerKey(match) {
+    const code = Number(match[1]);
+    const col = Number(match[2]) - 1;
+    const row = Number(match[3]) - 1;
+    const released = match[4] === "m";
+    const wheeling = (code & 64) !== 0;
+    const action = wheeling ? "wheel" : released ? "release" : (code & 32) !== 0 ? "move" : "press";
+    return {
+        name: "pointer",
+        text: "",
+        ctrl: (code & 16) !== 0,
+        pointer: {
+            action,
+            button: wheeling ? "none" : (BUTTONS[code & 3] ?? "none"),
+            wheel: wheeling ? ((code & 1) === 0 ? "up" : "down") : undefined,
+            col,
+            row,
+        },
+    };
+}

package/dist/tui/modal.js

@@ -0,0 +1,24 @@
+// What can take the dock over, and how it draws.
+//
+// Two kinds, and the union exists so that everything between the command that
+// opens one and the frame that draws it — the view, the shell, the key handler
+// — speaks about "the thing that is open" rather than about a picker and a
+// field separately. A third kind would be added here and nowhere else.
+import * as picker from "./picker.js";
+import * as field from "./field.js";
+export function panel(modal, width, pal, maxRows) {
+    return modal.kind === "pick"
+        ? picker.panel(modal.picker, width, pal, maxRows)
+        : maxRows === undefined
+            ? field.panel(modal.field, width, pal)
+            : field.panel(modal.field, width, pal).slice(0, maxRows);
+}
+/**
+ * Where the caret goes while this is open, if it goes anywhere.
+ *
+ * A menu is read, not typed into, so it hides the caret entirely — a blinking
+ * block on a row nobody is editing is an invitation to type into it.
+ */
+export function caret(modal, width) {
+    return modal.kind === "type" ? field.caret(modal.field, width) : undefined;
+}