@giovannijecha/jecode 0.1.5-rc.2

package/dist/tui/overlay.js

@@ -0,0 +1,93 @@
+// The modal interaction layer: one picker or one single-line field.
+import * as picker from "./picker.js";
+import { oneLine } from "./field.js";
+import { applyKey } from "./input.js";
+export function shown(open) {
+    if (open === undefined)
+        return undefined;
+    return "picker" in open ? { kind: "pick", picker: open.picker } : { kind: "type", field: open.field };
+}
+export function cancel(open) {
+    if (open === undefined)
+        return undefined;
+    open.settle(undefined);
+    return undefined;
+}
+export function handle(open, key) {
+    if (key.ctrl && key.name === "c") {
+        cancel(open);
+        return { abort: true };
+    }
+    if (key.ctrl && key.name === "d") {
+        cancel(open);
+        return { quit: true };
+    }
+    if (key.name === "escape") {
+        cancel(open);
+        return {};
+    }
+    return "picker" in open ? handlePicker(open, key) : handleField(open, key);
+}
+function handlePicker(open, key) {
+    switch (key.name) {
+        case "up":
+            open.picker = picker.move(open.picker, -1);
+            break;
+        case "down":
+            open.picker = picker.move(open.picker, 1);
+            break;
+        case "home":
+            open.picker = picker.edge(open.picker, "home");
+            break;
+        case "end":
+            open.picker = picker.edge(open.picker, "end");
+            break;
+        case "pageup":
+            open.picker = picker.page(open.picker, -1);
+            break;
+        case "pagedown":
+            open.picker = picker.page(open.picker, 1);
+            break;
+        case "backspace":
+            open.picker = picker.backspace(open.picker);
+            break;
+        case "enter":
+            if (picker.selected(open.picker) === undefined)
+                break;
+            open.settle(open.picker.index);
+            return {};
+        case "paste":
+            if (open.picker.searchable === true) {
+                open.picker = picker.type(open.picker, key.text.replace(/\s+/g, " "));
+            }
+            break;
+        case "char":
+            if (open.picker.searchable === true) {
+                open.picker = picker.type(open.picker, key.text);
+                break;
+            }
+            {
+                const index = picker.byKey(open.picker, key.text);
+                if (index === undefined)
+                    break;
+                open.settle(index);
+                return {};
+            }
+        default:
+            if (key.ctrl && key.name === "u" && open.picker.searchable === true) {
+                open.picker = picker.clear(open.picker);
+            }
+    }
+    return { open };
+}
+function handleField(open, key) {
+    if (key.name === "enter") {
+        const text = open.field.editor.text.trim();
+        open.settle(text === "" ? undefined : text);
+        return {};
+    }
+    const edited = applyKey(open.field.editor, key);
+    if (edited !== undefined)
+        open.field = { ...open.field, editor: oneLine(edited) };
+    return { open };
+}

package/dist/tui/picker.js

@@ -0,0 +1,99 @@
+// One interaction model for every terminal selector.
+import { row } from "../ui/render.js";
+import { elide } from "../ui/width.js";
+import { menuWindow, renderMenuRows } from "./components/menu.js";
+const WINDOW = 6;
+export function move(picker, step) {
+    const shown = matches(picker);
+    if (shown.length === 0)
+        return picker;
+    const at = Math.max(0, shown.findIndex((entry) => entry.index === picker.index));
+    return { ...picker, index: shown[((at + step) % shown.length + shown.length) % shown.length].index };
+}
+export function edge(picker, end) {
+    const shown = matches(picker);
+    const found = end === "home" ? shown[0] : shown.at(-1);
+    return found === undefined ? picker : { ...picker, index: found.index };
+}
+export function page(picker, direction, rows = WINDOW) {
+    return move(picker, direction * Math.max(1, rows));
+}
+export function type(picker, text) {
+    if (picker.searchable !== true || text === "")
+        return picker;
+    return withQuery(picker, `${picker.query ?? ""}${text}`);
+}
+export function backspace(picker) {
+    if (picker.searchable !== true || (picker.query ?? "") === "")
+        return picker;
+    return withQuery(picker, Array.from(picker.query ?? "").slice(0, -1).join(""));
+}
+export function clear(picker) {
+    return withQuery(picker, "");
+}
+export function selected(picker) {
+    return matches(picker).some((entry) => entry.index === picker.index) ? picker.index : undefined;
+}
+export function byKey(picker, text) {
+    const typed = text.trim().toLowerCase();
+    if (typed === "")
+        return undefined;
+    const digit = Number(typed);
+    if (Number.isInteger(digit) && digit >= 1 && digit <= picker.options.length)
+        return digit - 1;
+    const found = picker.options.findIndex((option) => option.key === typed);
+    return found === -1 ? undefined : found;
+}
+export function panel(picker, width, pal, maxRows = WINDOW + 4) {
+    const found = matches(picker);
+    const fixed = 2 + (picker.description === undefined ? 0 : 1) + (picker.searchable === true ? 1 : 0);
+    const optionRoom = Math.max(1, Math.min(WINDOW, maxRows - fixed));
+    const selectedAt = Math.max(0, found.findIndex((entry) => entry.index === picker.index));
+    const { first, last } = menuWindow(found.length, selectedAt, optionRoom);
+    const shown = found.slice(first, last);
+    const options = shown.length === 0
+        ? [row(width, [{ text: "  no matches", fg: pal.ink.muted }])]
+        : renderMenuRows(shown.map(({ option, index }) => ({
+            label: option.label,
+            hint: option.hint,
+            selected: index === picker.index,
+        })), width, pal);
+    const progress = found.length > shown.length || picker.searchable === true
+        ? `${found.length === 0 ? "0" : `${first + 1}–${first + shown.length}`} / ${found.length}` +
+            (found.length === picker.options.length ? "" : ` · ${picker.options.length} total`) + " · "
+        : "";
+    const footer = picker.footer ?? "Enter to select · Esc to close";
+    return [
+        row(width, picker.title, picker.right === undefined ? [] : [{ text: picker.right, fg: pal.ink.muted }]),
+        ...(picker.description === undefined
+            ? []
+            : [row(width, [{ text: picker.description, fg: pal.ink.muted }])]),
+        ...(picker.searchable === true
+            ? [
+                row(width, [
+                    { text: "  filter  ", fg: pal.ink.muted },
+                    { text: picker.query === "" || picker.query === undefined ? "type to search" : picker.query, fg: pal.ink.bright },
+                ]),
+            ]
+            : []),
+        ...options,
+        row(width, [{ text: `  ${elide(progress + footer, Math.max(1, width - 2))}`, fg: pal.ink.muted }]),
+    ];
+}
+export function heading(label, about, pal) {
+    return [
+        { text: `${label}  `, fg: pal.accent, bold: true },
+        { text: about, fg: pal.ink.fg },
+    ];
+}
+function matches(picker) {
+    const query = (picker.query ?? "").trim().toLocaleLowerCase();
+    return picker.options.flatMap((option, index) => {
+        const haystack = `${option.label} ${option.hint ?? ""}`.toLocaleLowerCase();
+        return query === "" || haystack.includes(query) ? [{ option, index }] : [];
+    });
+}
+function withQuery(picker, query) {
+    const next = { ...picker, query };
+    return { ...next, index: matches(next)[0]?.index ?? 0 };
+}

package/dist/tui/screen.js

@@ -0,0 +1,94 @@
+// The terminal, taken over and given back.
+//
+// A TUI owns the screen, and every takeover has to be undone — on a clean
+// exit, on a crash, on a signal. The restore is registered before the first
+// escape is written, never after: a process that dies holding raw mode leaves
+// the user with a shell that does not echo.
+import { CSI } from "../ui/render.js";
+const ALT_ON = `${CSI}?1049h`;
+const ALT_OFF = `${CSI}?1049l`;
+const CURSOR_HIDE = `${CSI}?25l`;
+const CURSOR_SHOW = `${CSI}?25h`;
+const PASTE_ON = `${CSI}?2004h`;
+const PASTE_OFF = `${CSI}?2004l`;
+// Auto-wrap off: every row is positioned absolutely and painted to the full
+// width, and a full-width write on the last row would otherwise scroll the
+// screen out from under the frame.
+const WRAP_OFF = `${CSI}?7l`;
+const WRAP_ON = `${CSI}?7h`;
+// Button events without drag (?1000) reported in SGR form (?1006). Wheel events
+// come with them, and the wheel is the reason to ask: a transcript that can
+// only be scrolled by keyboard reads as a transcript that cannot be scrolled.
+const MOUSE_ON = `${CSI}?1000h${CSI}?1006h`;
+const MOUSE_OFF = `${CSI}?1006l${CSI}?1000l`;
+// The caret, as a blinking filled cell rather than a hairline (DECSCUSR). A
+// bar is the default because a bar is what a text field wants; this is not a
+// text field, it is a screen jecode drew, and the block is the only mark on it
+// wide enough to find at a glance. Blinking on purpose: on a screen with no
+// other chrome around the input, a steady block is one more static glyph, and
+// motion is what says the thing is waiting for you. `0` puts the terminal back
+// on whatever the user chose.
+const CURSOR_BLOCK = `${CSI}1 q`;
+const CURSOR_STEADY = `${CSI}2 q`;
+const CURSOR_RESET = `${CSI}0 q`;
+// Synchronized output: the terminal is told to hold the screen until the frame
+// is complete. Without it a repaint mid-refresh is drawn half-old and
+// half-new, which is what tearing during a stream actually is.
+const SYNC_BEGIN = `${CSI}?2026h`;
+const SYNC_END = `${CSI}?2026l`;
+let active = false;
+export function interactive() {
+    return process.stdin.isTTY === true && process.stdout.isTTY === true;
+}
+export function size() {
+    return {
+        rows: Math.max(1, process.stdout.rows ?? 24),
+        cols: Math.max(1, process.stdout.columns ?? 80),
+    };
+}
+export function write(text) {
+    process.stdout.write(text);
+}
+export function enter(reducedMotion = false) {
+    if (active)
+        return;
+    active = true;
+    process.on("exit", leave);
+    process.on("SIGTERM", onFatalSignal);
+    process.on("SIGHUP", onFatalSignal);
+    write(ALT_ON + WRAP_OFF + CURSOR_HIDE + (reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK) + PASTE_ON + MOUSE_ON);
+    process.stdin.setRawMode(true);
+    process.stdin.setEncoding("utf8");
+    process.stdin.resume();
+}
+export function leave() {
+    if (!active)
+        return;
+    active = false;
+    if (process.stdin.isTTY === true)
+        process.stdin.setRawMode(false);
+    process.stdin.pause();
+    write(MOUSE_OFF + PASTE_OFF + CURSOR_RESET + CURSOR_SHOW + WRAP_ON + ALT_OFF);
+}
+export function setReducedMotion(reducedMotion) {
+    if (active)
+        write(reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK);
+}
+function onFatalSignal() {
+    leave();
+    process.exit(0);
+}
+export function onResize(handler) {
+    process.stdout.on("resize", handler);
+    return () => {
+        process.stdout.off("resize", handler);
+    };
+}
+export function onInput(handler) {
+    process.stdin.on("data", handler);
+    return () => {
+        process.stdin.off("data", handler);
+    };
+}
+export const CURSOR = { hide: CURSOR_HIDE, show: CURSOR_SHOW };
+export const SYNC = { begin: SYNC_BEGIN, end: SYNC_END };

package/dist/tui/scroll.js

@@ -0,0 +1,7 @@
+// Scroll offsets are measured from the bottom. Preserve what is being read as
+// the transcript grows, while offset zero keeps following new output.
+export function preserveOffset(offset, following, previousMax, nextMax) {
+    if (following)
+        return 0;
+    return Math.min(nextMax, Math.max(0, offset + Math.max(0, nextMax - previousMax)));
+}

package/dist/tui/session-view.js

@@ -0,0 +1,49 @@
+// Small projections of the live session used by the shell and footer.
+import { credentialSource } from "../credentials.js";
+import { providerFailure } from "../provider-errors.js";
+export function controllerOptions(session) {
+    return {
+        provider: session.provider,
+        tools: session.tools,
+        model: session.model,
+        system: session.system,
+        maxTokens: session.config.maxTokens,
+        effort: session.config.effort,
+        maxSteps: session.config.maxSteps,
+        toolContext: { root: session.config.root },
+    };
+}
+export function footerInfo(session, workspace = session.config.root) {
+    return {
+        workspace,
+        model: session.model || "no model",
+        effort: session.config.effort,
+    };
+}
+/** One transcript event for a real turn failure, including actionable auth guidance. */
+export function turnFailure(session, error, aborted) {
+    if (aborted)
+        return { kind: "notice", text: "[interrupted]", tone: "warn" };
+    let text = providerFailure(session.provider, error);
+    if (/\b401\b/.test(text)) {
+        const source = credentialSource(session.provider.keyVar);
+        text += source === "environment"
+            ? ` · update ${session.provider.keyVar} in the environment and restart`
+            : " · check credentials with /settings";
+    }
+    return { kind: "notice", text, tone: "error" };
+}
+export function toggleDetails(blocks) {
+    for (let index = blocks.length - 1; index >= 0; index--) {
+        const block = blocks[index];
+        if (block?.kind === "tool" && (block.body?.length ?? 0) > 0) {
+            block.expanded = block.expanded !== true;
+            return block;
+        }
+        if (block?.kind === "reasoning") {
+            block.expanded = block.expanded !== true;
+            return block;
+        }
+    }
+    return undefined;
+}

package/dist/tui/transcript-view.js

@@ -0,0 +1,134 @@
+// Incremental transcript layout for long-running sessions.
+import { render } from "./blocks.js";
+/**
+ * Keep block rows and cumulative row ends between frames.
+ *
+ * The app mutates semantic blocks while streaming, so it marks that one block
+ * dirty. Appends then cost one render, stable frames cost no block renders,
+ * and viewport selection starts with a binary search instead of flattening or
+ * scanning the complete transcript.
+ */
+export function transcriptRenderer(draw = render) {
+    let source;
+    let layoutWidth = -1;
+    let layoutPalette;
+    let entries = [];
+    let ends = [];
+    let positions = new WeakMap();
+    const dirty = new Set();
+    return {
+        viewport(blocks, width, height, scroll, palette) {
+            sync(blocks, width, palette);
+            const visibleHeight = Math.max(0, height);
+            const totalRows = ends.at(-1) ?? 0;
+            const maxScroll = Math.max(0, totalRows - visibleHeight);
+            const offset = Math.min(Math.max(0, scroll), maxScroll);
+            const start = Math.max(0, totalRows - visibleHeight - offset);
+            const end = start + visibleHeight;
+            const rows = [];
+            let index = firstEndingAfter(start);
+            let at = index === 0 ? 0 : (ends[index - 1] ?? 0);
+            while (index < entries.length && at < end) {
+                const blockRows = entries[index]?.rows ?? [];
+                rows.push(...blockRows.slice(Math.max(0, start - at), Math.min(blockRows.length, end - at)));
+                at = ends[index] ?? at;
+                index++;
+            }
+            while (rows.length < visibleHeight)
+                rows.unshift("");
+            return { rows, maxScroll };
+        },
+        invalidate(block) {
+            if (block !== undefined) {
+                dirty.add(block);
+                return;
+            }
+            source = undefined;
+            entries = [];
+            ends = [];
+            positions = new WeakMap();
+            dirty.clear();
+        },
+    };
+    function sync(blocks, width, palette) {
+        if (source !== blocks ||
+            layoutWidth !== width ||
+            layoutPalette !== palette ||
+            blocks.length < entries.length ||
+            edgeChanged(blocks)) {
+            rebuild(blocks, width, palette);
+            return;
+        }
+        append(blocks, width, palette);
+        refreshDirty(width, palette);
+    }
+    function rebuild(blocks, width, palette) {
+        source = blocks;
+        layoutWidth = width;
+        layoutPalette = palette;
+        entries = [];
+        ends = [];
+        positions = new WeakMap();
+        dirty.clear();
+        append(blocks, width, palette);
+    }
+    function append(blocks, width, palette) {
+        let total = ends.at(-1) ?? 0;
+        for (let index = entries.length; index < blocks.length; index++) {
+            const block = blocks[index];
+            if (block === undefined)
+                continue;
+            const rows = draw(block, width, palette);
+            entries.push({ block, rows });
+            positions.set(block, index);
+            dirty.delete(block);
+            total += rows.length;
+            ends.push(total);
+        }
+    }
+    function refreshDirty(width, palette) {
+        if (dirty.size === 0)
+            return;
+        const changed = [...dirty]
+            .map((block) => positions.get(block))
+            .filter((index) => index !== undefined)
+            .sort((left, right) => left - right);
+        dirty.clear();
+        if (changed.length === 0)
+            return;
+        const first = changed[0];
+        for (const index of changed) {
+            const entry = entries[index];
+            if (entry !== undefined)
+                entry.rows = draw(entry.block, width, palette);
+        }
+        recomputeEnds(first);
+    }
+    function recomputeEnds(from) {
+        let total = from === 0 ? 0 : (ends[from - 1] ?? 0);
+        for (let index = from; index < entries.length; index++) {
+            total += entries[index]?.rows.length ?? 0;
+            ends[index] = total;
+        }
+    }
+    function edgeChanged(blocks) {
+        if (entries.length === 0)
+            return false;
+        const lastShared = Math.min(blocks.length, entries.length) - 1;
+        return lastShared < 0 ||
+            entries[0]?.block !== blocks[0] ||
+            entries[lastShared]?.block !== blocks[lastShared];
+    }
+    function firstEndingAfter(row) {
+        let low = 0;
+        let high = ends.length;
+        while (low < high) {
+            const middle = Math.floor((low + high) / 2);
+            if ((ends[middle] ?? 0) <= row)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        return low;
+    }
+}