mergestorm 0.3.8 → 0.3.13

package/dist/ui/prompt.js

@@ -1,8 +1,8 @@
 import * as readline from "node:readline";
 import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
+import { stdin, stdout } from "node:process";
 import { ansi } from "./ansi.js";
-import { frameWidth, preferBoxedUi, roundedBox, visibleWidth } from "./box.js";
+import { frameWidth, preferBoxedUi, roundedBox, sliceVisible, terminalColumns, visibleWidth, } from "./box.js";
 import { CTRL_C_EXIT_HINT, CtrlCExitGate } from "./ctrl-c-exit.js";
 /** Thrown when the user asks to close the prompt (Ctrl+D empty, or Ctrl+C twice). */
 export class PromptClosedError extends Error {
@@ -11,11 +11,171 @@ export class PromptClosedError extends Error {
         this.name = "PromptClosedError";
     }
 }
-const up = (n) => `[${n}A`;
-const down = (n) => `[${n}B`;
-const col = (n) => `[${n}G`;
-const clearDown = "";
-async function fallbackAskLine(promptLabel) {
+const up = (n) => `\u001b[${n}A`;
+const down = (n) => `\u001b[${n}B`;
+const col = (n) => `\u001b[${n}G`;
+const clearDown = "\u001b[0J";
+/**
+ * Redraw prefix from the parked content-row cursor.
+ * CUU keeps the column, so CR must come before ED 0 or leftover
+ * prompt cells survive (`merg` + `mergestorm` -> `mergmmmmmergestorm`).
+ */
+export function promptRedrawPrefix(inputRow) {
+    return `${up(inputRow)}\r${clearDown}`;
+}
+/**
+ * From the content row, move to the first row after the input chrome
+ * and erase the slash overlay. Boxed chrome is top + content + bottom
+ * (`down(2)`). Plain chrome is the content line (`down(1)`).
+ */
+export function promptClearOverlay(boxed) {
+    return `${down(boxed ? 2 : 1)}\r${clearDown}`;
+}
+export const DROPDOWN_MAX_COMMAND_ROWS = 8;
+export function formatSlashLabel(spec) {
+    const extra = spec.aliases?.length
+        ? ` \u00b7 ${spec.aliases.join(" \u00b7 ")}`
+        : "";
+    return `/${spec.name}${extra}`;
+}
+export function specMatchesTerm(spec, term) {
+    if (spec.name.toLowerCase().startsWith(term))
+        return true;
+    return (spec.aliases ?? []).some((alias) => alias.toLowerCase().startsWith(term));
+}
+export function slashToken(buffer) {
+    if (!buffer.startsWith("/"))
+        return null;
+    return buffer.slice(1).split(/\s/, 1)[0].toLowerCase();
+}
+export function matchSlashCommands(buffer, specs, dismissed = false) {
+    if (dismissed)
+        return [];
+    const token = slashToken(buffer);
+    if (token == null)
+        return [];
+    return specs.filter((spec) => specMatchesTerm(spec, token));
+}
+export function isExactSlashCommand(buffer, specs) {
+    const token = slashToken(buffer);
+    if (!token)
+        return false;
+    return specs.some((spec) => spec.name === token || (spec.aliases ?? []).includes(token));
+}
+export function dropdownMaxRows(terminalRows, inputRow) {
+    const rows = typeof terminalRows === "number" && Number.isFinite(terminalRows) && terminalRows >= 1
+        ? terminalRows
+        : 24;
+    return Math.max(1, Math.min(DROPDOWN_MAX_COMMAND_ROWS, rows - inputRow - 3));
+}
+export function dropdownViewport(count, index, maxRows) {
+    const max = Math.max(1, maxRows);
+    if (count <= max)
+        return { start: 0, moreAbove: 0, moreBelow: 0 };
+    const clampedIndex = Math.max(0, Math.min(index, count - 1));
+    let start = 0;
+    if (clampedIndex >= max)
+        start = clampedIndex - max + 1;
+    if (start + max > count)
+        start = Math.max(0, count - max);
+    return {
+        start,
+        moreAbove: start,
+        moreBelow: Math.max(0, count - start - max),
+    };
+}
+/** Overlay rows (no invert). At most `maxRows` commands plus edge markers. */
+export function dropdownOverlayRows(dropdown, index, maxRows) {
+    const view = dropdownViewport(dropdown.length, index, maxRows);
+    const rows = [];
+    if (view.moreAbove > 0)
+        rows.push({ text: `  \u2191 ${view.moreAbove} more` });
+    const end = Math.min(dropdown.length, view.start + Math.max(1, maxRows));
+    for (let i = view.start; i < end; i++) {
+        const spec = dropdown[i];
+        rows.push({
+            text: `  ${formatSlashLabel(spec).padEnd(22)}${spec.summary}`,
+            selected: i === index,
+        });
+    }
+    if (view.moreBelow > 0)
+        rows.push({ text: `  \u2193 ${view.moreBelow} more` });
+    return rows;
+}
+/** Input prefix glyph (U+203A), kept as an escape so editors can't mangle it. */
+export const INPUT_PREFIX_GLYPH = "\u203a";
+/** Cells the `> ` prefix occupies before the buffer. */
+export const INPUT_PREFIX_CELLS = 2;
+/** Padding inside the boxed input frame. */
+export const INPUT_BOX_PADDING = 1;
+/**
+ * Horizontal scroll for a one-row editor: pick the `cells`-wide window of
+ * `buffer` that keeps the cursor on screen, moving the previous window only
+ * when the cursor leaves it. Never wraps onto a second physical row.
+ */
+export function inputWindow(buffer, cursor, cells, prevStart = 0) {
+    if (cells <= 0)
+        return { start: 0, text: "", cursorCol: 0 };
+    const cursorCells = visibleWidth(buffer.slice(0, Math.max(0, cursor)));
+    const totalCells = visibleWidth(buffer);
+    // The cursor needs a cell of its own at end-of-line, so a full window
+    // shows at most `cells - 1` glyphs past the scroll origin.
+    const maxStart = Math.max(0, totalCells - (cells - 1));
+    let start = Math.min(Math.max(0, prevStart), maxStart);
+    if (cursorCells < start)
+        start = cursorCells;
+    if (cursorCells > start + cells - 1)
+        start = cursorCells - (cells - 1);
+    return {
+        start,
+        text: sliceVisible(buffer, start, cells),
+        cursorCol: cursorCells - start,
+    };
+}
+/** Cells available to the buffer (after the prefix) on a content row. */
+export function inputCells(columns) {
+    const boxed = preferBoxedUi(columns);
+    const contentCells = boxed
+        ? frameWidth(80, columns) - 2 - INPUT_BOX_PADDING * 2
+        : terminalColumns(80, columns) - 1;
+    return { boxed, cells: Math.max(0, contentCells - INPUT_PREFIX_CELLS) };
+}
+/**
+ * Everything one prompt redraw writes, computed from the current terminal
+ * width. Every row fits in `columns - 1` cells so nothing wraps and the
+ * CUU count on the next redraw stays honest.
+ */
+export function buildPromptFrame(params) {
+    const { boxed, cells } = inputCells(params.columns);
+    const cols = terminalColumns(80, params.columns);
+    const win = inputWindow(params.buffer, params.cursor, cells, params.scrollStart ?? 0);
+    const inputRow = (params.prompt ? 1 : 0) + (boxed ? 1 : 0);
+    // Nothing we emit may wrap: a wrapped row is one the CUU count can't see.
+    const clip = (text) => visibleWidth(text) > cols - 1 ? sliceVisible(text, 0, cols - 1) : text;
+    const rows = [];
+    if (params.prompt)
+        rows.push(ansi.dim(clip(params.prompt)));
+    const inputLine = `${ansi.green(INPUT_PREFIX_GLYPH)} ${win.text}`;
+    if (boxed) {
+        // Full terminal width input frame, not content-sized.
+        rows.push(...roundedBox([inputLine], {
+            padding: INPUT_BOX_PADDING,
+            width: frameWidth(80, params.columns),
+        }));
+    }
+    else {
+        // Plain prompt on narrow TTYs (avoids wrapped borders).
+        rows.push(inputLine);
+    }
+    for (const row of params.overlay ?? []) {
+        const text = clip(row.text);
+        rows.push(row.selected ? ansi.invert(text) : ansi.gray(text));
+    }
+    // Boxed: border col + padding; plain: column 1.
+    const targetCol = (boxed ? 1 + INPUT_BOX_PADDING : 0) + INPUT_PREFIX_CELLS + win.cursorCol + 1;
+    return { rows, boxed, inputRow, targetCol, scrollStart: win.start };
+}
+async function fallbackAskLine(promptLabel, input, output) {
     const rl = createInterface({ input, output, terminal: false });
     try {
         return await rl.question(promptLabel ? `${promptLabel}> ` : "> ");
@@ -31,68 +191,80 @@ async function fallbackAskLine(promptLabel) {
 export async function askLine(opts) {
     const commands = opts.commands ?? [];
     const history = opts.history ?? [];
+    const input = opts.input ?? stdin;
+    const output = opts.output ?? stdout;
     if (!input.isTTY || !output.isTTY) {
-        return fallbackAskLine(opts.prompt);
+        return fallbackAskLine(opts.prompt, input, output);
     }
     return new Promise((resolve, reject) => {
         let buffer = "";
         let cursor = 0;
         let historyIndex = history.length;
         let dropdownIndex = 0;
+        let dropdownDismissed = false;
         let linesDrawn = 0;
+        // Geometry of the frame currently on screen. The redraw prefix and the
+        // final overlay clear must use *these*, not a fresh measurement, because
+        // the cursor is parked relative to what was actually drawn.
+        let drawnInputRow = 0;
+        let drawnBoxed = true;
+        let scrollStart = 0;
         let finished = false;
         const ctrlCExit = new CtrlCExitGate();
         const wasRaw = Boolean(input.isRaw);
         readline.emitKeypressEvents(input);
         input.setRawMode(true);
         input.resume();
-        const boxed = preferBoxedUi();
-        // Row (0-based) of the "› buffer" content line among the rows we draw each frame.
-        // Boxed: optional prompt + top border + content. Plain: optional prompt + content.
-        const inputRow = (opts.prompt ? 1 : 0) + (boxed ? 1 : 0);
         function currentDropdown() {
-            if (!buffer.startsWith("/"))
-                return [];
-            const term = buffer.slice(1).toLowerCase();
-            return commands.filter((c) => c.name.toLowerCase().startsWith(term));
+            return matchSlashCommands(buffer, commands, dropdownDismissed);
+        }
+        function setBuffer(next) {
+            if (next !== buffer)
+                dropdownDismissed = false;
+            buffer = next;
         }
         function render() {
             if (linesDrawn > 0) {
-                output.write(`${up(inputRow)}${clearDown}`);
-            }
-            const rows = [];
-            if (opts.prompt)
-                rows.push(ansi.dim(opts.prompt));
-            const inputLine = `${ansi.green("›")} ${buffer}`;
-            if (boxed) {
-                // Full terminal width input frame, not content-sized.
-                rows.push(...roundedBox([inputLine], { padding: 1, width: frameWidth() }));
-            }
-            else {
-                // Plain prompt on narrow TTYs (avoids wrapped borders).
-                rows.push(inputLine);
+                output.write(promptRedrawPrefix(drawnInputRow));
             }
+            // Re-measured every frame: the terminal may have been resized since
+            // the last draw, flipping boxed/plain or changing the frame width.
+            const columns = opts.columns ?? output.columns;
+            const boxedNow = preferBoxedUi(columns);
+            const inputRowNow = (opts.prompt ? 1 : 0) + (boxedNow ? 1 : 0);
             const dropdown = currentDropdown();
+            let overlay = [];
             if (dropdown.length) {
                 if (dropdownIndex >= dropdown.length)
                     dropdownIndex = dropdown.length - 1;
-                dropdown.forEach((c, i) => {
-                    const label = `  /${c.name.padEnd(12)}${c.summary}`;
-                    rows.push(i === dropdownIndex ? ansi.invert(label) : ansi.gray(label));
-                });
+                const maxRows = dropdownMaxRows(opts.rows ?? output.rows, inputRowNow);
+                overlay = dropdownOverlayRows(dropdown, dropdownIndex, maxRows);
             }
             else {
                 dropdownIndex = 0;
             }
-            output.write(rows.join("\r\n") + "\r\n");
-            linesDrawn = rows.length;
-            const prefixWidth = visibleWidth(`${ansi.green("›")} `);
-            // Boxed: border col + padding; plain: column 1.
-            const targetCol = (boxed ? 1 + 1 : 0) + prefixWidth + cursor + 1;
-            output.write(`${up(linesDrawn - inputRow)}${col(targetCol)}`);
+            const frame = buildPromptFrame({
+                prompt: opts.prompt,
+                buffer,
+                cursor,
+                columns,
+                scrollStart,
+                overlay,
+            });
+            output.write(frame.rows.join("\r\n") + "\r\n");
+            linesDrawn = frame.rows.length;
+            drawnInputRow = frame.inputRow;
+            drawnBoxed = frame.boxed;
+            scrollStart = frame.scrollStart;
+            output.write(`${up(linesDrawn - frame.inputRow)}${col(frame.targetCol)}`);
+        }
+        function onResize() {
+            if (!finished)
+                render();
         }
         function cleanup() {
             input.removeListener("keypress", onKeypress);
+            output.removeListener("resize", onResize);
             input.setRawMode(wasRaw);
             // emitKeypressEvents leaves stdin flowing; pause it so an idle shell
             // (no command running) doesn't keep the process alive after exit/EOF.
@@ -103,9 +275,8 @@ export async function askLine(opts) {
                 return;
             finished = true;
             cleanup();
-            const rowsBelow = Math.max(0, linesDrawn - inputRow - 1);
-            if (rowsBelow > 0)
-                output.write(down(rowsBelow));
+            if (linesDrawn > 0)
+                output.write(promptClearOverlay(drawnBoxed));
             output.write("\n");
             if (err)
                 reject(err);
@@ -113,7 +284,7 @@ export async function askLine(opts) {
                 resolve(value ?? "");
         }
         function acceptDropdown(dropdown) {
-            buffer = `/${dropdown[dropdownIndex].name} `;
+            setBuffer(`/${dropdown[dropdownIndex].name} `);
             cursor = buffer.length;
             dropdownIndex = 0;
         }
@@ -129,12 +300,13 @@ export async function askLine(opts) {
                         finish(null, new PromptClosedError());
                         return;
                     }
-                    buffer = "";
+                    setBuffer("");
                     cursor = 0;
+                    scrollStart = 0;
                     historyIndex = history.length;
-                    const rowsBelow = Math.max(0, linesDrawn - inputRow - 1);
-                    if (rowsBelow > 0)
-                        output.write(down(rowsBelow));
+                    dropdownIndex = 0;
+                    if (linesDrawn > 0)
+                        output.write(promptClearOverlay(drawnBoxed));
                     output.write(`\n${ansi.dim(CTRL_C_EXIT_HINT)}\n`);
                     linesDrawn = 0;
                     render();
@@ -145,9 +317,18 @@ export async function askLine(opts) {
                         finish(null, new PromptClosedError());
                     return;
                 }
-                if (key.name === "return") {
+                if (key.name === "escape") {
                     if (dropdown.length)
-                        buffer = `/${dropdown[dropdownIndex].name}`;
+                        dropdownDismissed = true;
+                    render();
+                    return;
+                }
+                if (key.name === "return") {
+                    if (dropdown.length &&
+                        !dropdownDismissed &&
+                        !isExactSlashCommand(buffer, dropdown)) {
+                        setBuffer(`/${dropdown[dropdownIndex].name}`);
+                    }
                     finish(buffer);
                     return;
                 }
@@ -158,10 +339,7 @@ export async function askLine(opts) {
                     return;
                 }
                 if (key.name === "right") {
-                    if (dropdown.length)
-                        acceptDropdown(dropdown);
-                    else
-                        cursor = Math.min(buffer.length, cursor + 1);
+                    cursor = Math.min(buffer.length, cursor + 1);
                     render();
                     return;
                 }
@@ -172,11 +350,11 @@ export async function askLine(opts) {
                 }
                 if (key.name === "up") {
                     if (dropdown.length) {
-                        dropdownIndex = (dropdownIndex - 1 + dropdown.length) % dropdown.length;
+                        dropdownIndex = Math.max(0, dropdownIndex - 1);
                     }
                     else if (history.length) {
                         historyIndex = Math.max(0, historyIndex - 1);
-                        buffer = history[historyIndex] ?? "";
+                        setBuffer(history[historyIndex] ?? "");
                         cursor = buffer.length;
                     }
                     render();
@@ -184,11 +362,11 @@ export async function askLine(opts) {
                 }
                 if (key.name === "down") {
                     if (dropdown.length) {
-                        dropdownIndex = (dropdownIndex + 1) % dropdown.length;
+                        dropdownIndex = Math.min(dropdown.length - 1, dropdownIndex + 1);
                     }
                     else if (history.length) {
                         historyIndex = Math.min(history.length, historyIndex + 1);
-                        buffer = historyIndex >= history.length ? "" : history[historyIndex] ?? "";
+                        setBuffer(historyIndex >= history.length ? "" : history[historyIndex] ?? "");
                         cursor = buffer.length;
                     }
                     render();
@@ -205,31 +383,31 @@ export async function askLine(opts) {
                     return;
                 }
                 if (key.ctrl && key.name === "u") {
-                    buffer = buffer.slice(cursor);
+                    setBuffer(buffer.slice(cursor));
                     cursor = 0;
                     render();
                     return;
                 }
                 if (key.ctrl && key.name === "k") {
-                    buffer = buffer.slice(0, cursor);
+                    setBuffer(buffer.slice(0, cursor));
                     render();
                     return;
                 }
                 if (key.name === "backspace") {
                     if (cursor > 0) {
-                        buffer = buffer.slice(0, cursor - 1) + buffer.slice(cursor);
+                        setBuffer(buffer.slice(0, cursor - 1) + buffer.slice(cursor));
                         cursor -= 1;
                     }
                     render();
                     return;
                 }
                 if (key.name === "delete") {
-                    buffer = buffer.slice(0, cursor) + buffer.slice(cursor + 1);
+                    setBuffer(buffer.slice(0, cursor) + buffer.slice(cursor + 1));
                     render();
                     return;
                 }
                 if (str && !key.ctrl && !key.meta) {
-                    buffer = buffer.slice(0, cursor) + str + buffer.slice(cursor);
+                    setBuffer(buffer.slice(0, cursor) + str + buffer.slice(cursor));
                     cursor += str.length;
                     render();
                 }
@@ -239,6 +417,7 @@ export async function askLine(opts) {
             }
         }
         input.on("keypress", onKeypress);
+        output.on("resize", onResize);
         render();
     });
 }

package/dist/ui/usage.d.ts

@@ -9,7 +9,7 @@ export type UsageBarOpts = {
  *   `[████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 7% used`
  *
  * No used/limit clutter. Edge cases:
- * - `limit === 0` → dim "not included" (premium on non-Maelstrom)
+ * - `limit === 0` → dim "not included"
  * - `limit == null` → "unlimited" (dev-bypass)
  */
 export declare function usageBar(used: number, limit: number | null | undefined, opts?: UsageBarOpts): string;
@@ -22,3 +22,27 @@ export declare function nextUtcMonthStart(now?: Date): string;
 export declare function formatResetLabel(iso: string | null | undefined, now?: Date): string;
 /** Alias kept for callers that still import `formatResetDate`. */
 export declare function formatResetDate(iso: string | null | undefined): string;
+/** Bar cells so `  [bar] 100% used` stays inside the terminal. */
+export declare function usageBarWidth(columns: number): number;
+export type UsagePanelJob = {
+    job: string;
+    verdict: string;
+    thread: string;
+    credits: string;
+    when: string;
+};
+export type UsagePanelInput = {
+    keyPrefix: string;
+    plan: string;
+    used: number;
+    limit: number | null;
+    resetsAt: string | null | undefined;
+    jobs: UsagePanelJob[];
+    columns: number;
+    color?: boolean;
+};
+/**
+ * Static `/usage` panel: identity, a bar sized from `frameWidth()`, reset
+ * line, then the last five jobs. Every row is clipped to `columns`.
+ */
+export declare function formatUsagePanel(input: UsagePanelInput): string[];

package/dist/ui/usage.js

@@ -1,10 +1,12 @@
 import { ansi } from "./ansi.js";
+import { frameWidth } from "./box.js";
+import { padVisible, visibleWidth } from "./width.js";
 /**
  * Usage meter — long thin bar + percent only:
  *   `[████████████░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░] 7% used`
  *
  * No used/limit clutter. Edge cases:
- * - `limit === 0` → dim "not included" (premium on non-Maelstrom)
+ * - `limit === 0` → dim "not included"
  * - `limit == null` → "unlimited" (dev-bypass)
  */
 export function usageBar(used, limit, opts = {}) {
@@ -65,3 +67,50 @@ export function formatResetLabel(iso, now = new Date()) {
 export function formatResetDate(iso) {
     return formatResetLabel(iso);
 }
+/** Bar cells so `  [bar] 100% used` stays inside the terminal. */
+export function usageBarWidth(columns) {
+    return Math.max(8, frameWidth(80, columns) - 13);
+}
+function clipLine(line, columns) {
+    if (visibleWidth(line) <= columns)
+        return line;
+    return padVisible(line, columns);
+}
+/**
+ * Static `/usage` panel: identity, a bar sized from `frameWidth()`, reset
+ * line, then the last five jobs. Every row is clipped to `columns`.
+ */
+export function formatUsagePanel(input) {
+    const columns = Math.max(20, input.columns);
+    const color = input.color ?? false;
+    const identity = `● ${input.keyPrefix} · ${input.plan}`;
+    const bar = usageBar(input.used, input.limit, {
+        width: usageBarWidth(columns),
+        color,
+    });
+    const lines = [
+        `  ${identity}`,
+        `  ${bar}`,
+        `  ${formatResetLabel(input.resetsAt)}`,
+        "",
+    ];
+    if (input.jobs.length === 0) {
+        lines.push("  No review jobs yet.");
+        return lines.map((line) => clipLine(line, columns));
+    }
+    const inner = Math.max(20, columns - 2);
+    const jobW = 8;
+    const verdictW = 15;
+    const creditsW = 7;
+    const whenW = 8;
+    const gaps = 8;
+    const threadW = Math.max(6, inner - jobW - verdictW - creditsW - whenW - gaps);
+    const header = ["JOB", "VERDICT", "THREAD", "CREDITS", "WHEN"];
+    const widths = [jobW, verdictW, threadW, creditsW, whenW];
+    const fmt = (cols) => "  " + cols.map((c, i) => padVisible(c, widths[i])).join("  ");
+    lines.push(fmt(header));
+    for (const job of input.jobs.slice(0, 5)) {
+        lines.push(fmt([job.job, job.verdict, job.thread, job.credits, job.when]));
+    }
+    return lines.map((line) => clipLine(line, columns));
+}

package/dist/ui/width.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Terminal cell arithmetic. Everything that frames, pads, or parks a cursor
+ * must count *cells*, not UTF-16 units: CJK is two cells, combining marks
+ * and ZWJ are zero, an astral emoji is one grapheme. Getting this wrong is
+ * why the right border of the prompt box drifted on non-Latin input.
+ */
+export declare function stripSgr(str: string): string;
+/** Cells for one code point on its own (no cluster context). */
+export declare function codePointWidth(cp: number): number;
+/**
+ * Cells one grapheme cluster occupies. A cluster is as wide as its widest
+ * base (a ZWJ family emoji is 2, not 6); VS16 promotes a text-style symbol
+ * to emoji presentation (2 cells); a cluster of nothing but marks is 0.
+ */
+export declare function graphemeWidth(cluster: string): number;
+/** Terminal cells a string occupies, ignoring SGR colour codes. */
+export declare function visibleWidth(str: string): number;
+/**
+ * Take the cells `[start, start + cells)` of `str`, keeping every SGR code
+ * (so colours survive) and substituting spaces for a wide glyph cut by
+ * either edge, so the result's geometry is exactly what the caller asked
+ * for even when a CJK character straddles the window.
+ */
+export declare function sliceVisible(str: string, start: number, cells: number): string;
+/** Pad or truncate to an exact cell width (ANSI-safe). */
+export declare function padVisible(line: string, width: number): string;