mergestorm 0.3.9 → 0.3.15

package/dist/ui/line-tabs.js

@@ -0,0 +1,170 @@
+import * as readline from "node:readline";
+import { stdin, stdout } from "node:process";
+import { ansi } from "./ansi.js";
+import { frameWidth, preferBoxedUi, roundedBox, terminalColumns, } from "./box.js";
+import { padVisible, visibleWidth } from "./width.js";
+import { tabsBodyRows, tabsHintLine } from "./tabs.js";
+export function initialLineTabsState(tabCount, start = 0) {
+    const n = Math.max(1, tabCount);
+    return {
+        index: Math.max(0, Math.min(start, n - 1)),
+        scroll: Array.from({ length: n }, () => 0),
+    };
+}
+export function reduceLineTabsKey(state, key, tabCount, maxScroll) {
+    if (key === "q" || key === "escape")
+        return { kind: "close" };
+    const last = Math.max(0, tabCount - 1);
+    if (key === "left") {
+        return { kind: "state", state: { ...state, index: Math.max(0, state.index - 1) } };
+    }
+    if (key === "right") {
+        return { kind: "state", state: { ...state, index: Math.min(last, state.index + 1) } };
+    }
+    const scroll = state.scroll.slice();
+    const at = state.index;
+    if (key === "up")
+        scroll[at] = Math.max(0, (scroll[at] ?? 0) - 1);
+    if (key === "down")
+        scroll[at] = Math.min(maxScroll, (scroll[at] ?? 0) + 1);
+    return { kind: "state", state: { ...state, scroll } };
+}
+function titleOf(tabs, index, color) {
+    const parts = tabs.map((tab, i) => {
+        if (!color)
+            return i === index ? `[${tab.label}]` : ` ${tab.label} `;
+        return i === index ? ansi.boldBrightGreen(tab.label) : ansi.dim(tab.label);
+    });
+    return parts.join(color ? ansi.dim(" · ") : " · ");
+}
+export function layoutLineTabs(tabs, state, columns, rows, color = false) {
+    const boxed = preferBoxedUi(columns);
+    const cols = terminalColumns(80, columns);
+    const outer = frameWidth(80, columns);
+    const contentCells = boxed ? Math.max(20, outer - 4) : Math.max(20, cols - 1);
+    const bodyRows = tabsBodyRows(rows);
+    const tab = tabs[state.index] ?? tabs[0];
+    const content = tab ? tab.lines : [];
+    const start = Math.min(Math.max(0, state.scroll[state.index] ?? 0), Math.max(0, content.length - bodyRows));
+    const clip = (line) => visibleWidth(line) > contentCells ? padVisible(line, contentCells) : line;
+    const body = content.slice(start, start + bodyRows).map(clip);
+    while (body.length < bodyRows)
+        body.push("");
+    const hint = tabsHintLine("←→ tabs · ↑↓ scroll · esc close", undefined, cols, color);
+    const title = titleOf(tabs, state.index, color);
+    if (!boxed) {
+        const plainTitle = visibleWidth(title) > cols - 1 ? padVisible(title, cols - 1) : title;
+        return { lines: [plainTitle, ...body, hint], bodyRows, contentRows: content.length };
+    }
+    return {
+        lines: [...roundedBox(body, { title, width: outer, padding: 1 }), hint],
+        bodyRows,
+        contentRows: content.length,
+    };
+}
+const up = (n) => `\u001b[${n}A`;
+const clearDown = "\u001b[0J";
+const homeClear = `\u001b[H${clearDown}`;
+/** Hold-to-read panel. TTY: tabbed frame. Pipe: print the lines. */
+export async function showLinePanel(label, lines) {
+    const input = stdin;
+    const output = stdout;
+    if (!input.isTTY || !output.isTTY) {
+        for (const line of lines)
+            console.log(line);
+        return;
+    }
+    const id = label.toLowerCase().replace(/[^a-z0-9]+/g, "-") || "page";
+    await runLineTabsBrowser({ tabs: [{ id, label, lines }] });
+}
+export async function runLineTabsBrowser(opts) {
+    const input = opts.input ?? stdin;
+    const output = opts.output ?? stdout;
+    const tabs = opts.tabs;
+    const color = opts.color ?? ansi.enabled;
+    if (!input.isTTY || !output.isTTY) {
+        for (const tab of tabs) {
+            console.log(`  ${tab.label}`);
+            for (const line of tab.lines)
+                console.log(line);
+            console.log("");
+        }
+        return;
+    }
+    return new Promise((resolve) => {
+        let state = initialLineTabsState(tabs.length, opts.initial ?? 0);
+        let lastLayout = null;
+        let linesDrawn = 0;
+        let finished = false;
+        const wasRaw = Boolean(input.isRaw);
+        readline.emitKeypressEvents(input);
+        input.setRawMode(true);
+        input.resume();
+        function render(prefix) {
+            if (prefix)
+                output.write(prefix);
+            else if (linesDrawn > 0)
+                output.write(`${up(linesDrawn)}\r${clearDown}`);
+            lastLayout = layoutLineTabs(tabs, state, output.columns, output.rows, color);
+            output.write(lastLayout.lines.join("\r\n") + "\r\n");
+            linesDrawn = lastLayout.lines.length;
+        }
+        function finish() {
+            if (finished)
+                return;
+            finished = true;
+            input.removeListener("keypress", onKeypress);
+            output.removeListener("resize", onResize);
+            input.setRawMode(wasRaw);
+            input.pause();
+            if (linesDrawn > 0)
+                output.write(`${up(linesDrawn)}\r${clearDown}`);
+            resolve();
+        }
+        function onResize() {
+            if (!finished)
+                render(homeClear);
+        }
+        function onKeypress(str, key) {
+            if (finished || !key)
+                return;
+            if (key.ctrl && key.name === "c") {
+                finish();
+                return;
+            }
+            let name = null;
+            if (key.name === "left" || key.name === "right" || key.name === "up" || key.name === "down") {
+                name = key.name;
+            }
+            else if (key.name === "escape")
+                name = "escape";
+            else if (key.name === "q" || str === "q")
+                name = "q";
+            if (!name)
+                return;
+            const maxScroll = lastLayout
+                ? Math.max(0, lastLayout.contentRows - lastLayout.bodyRows)
+                : 0;
+            const step = reduceLineTabsKey(state, name, tabs.length, maxScroll);
+            if (step.kind === "close") {
+                finish();
+                return;
+            }
+            state = step.state;
+            try {
+                render();
+            }
+            catch {
+                finish();
+            }
+        }
+        input.on("keypress", onKeypress);
+        output.on("resize", onResize);
+        try {
+            render(homeClear);
+        }
+        catch {
+            finish();
+        }
+    });
+}

package/dist/ui/logo.d.ts

@@ -1,5 +1,13 @@
 /**
- * Pixelated funnel logo, colored by the caller (see banner.ts).
- * Kept as plain glyphs here so consumers can measure/center it with visibleWidth.
+ * Compact two-row storm mark (Fable / 0.3.14 home). Colored by the caller.
+ * Block elements (U+2580..259F) are one cell each; no emoji, no gradients.
  */
+export declare const STORM_MARK: string[];
+/** Widest row of the mark, in cells (every mark glyph is single-cell). */
+export declare const STORM_MARK_WIDTH: number;
+/** @deprecated Alias — the home panel uses {@link STORM_MARK}. */
 export declare const TORNADO_LOGO: string[];
+/** @deprecated Alias. */
+export declare const TORNADO_LOGO_WIDTH: number;
+/** @deprecated Compact home is the full two-row mark. */
+export declare const TORNADO_LOGO_COMPACT: string[];

package/dist/ui/logo.js

@@ -1,12 +1,16 @@
 /**
- * Pixelated funnel logo, colored by the caller (see banner.ts).
- * Kept as plain glyphs here so consumers can measure/center it with visibleWidth.
+ * Compact two-row storm mark (Fable / 0.3.14 home). Colored by the caller.
+ * Block elements (U+2580..259F) are one cell each; no emoji, no gradients.
  */
-export const TORNADO_LOGO = [
-    "▟██████████▛",
-    " ▜████████▛",
-    "  ▝▜████▛▘",
-    "    ▜██▛",
-    "     ██",
-    "     ▝▘",
+export const STORM_MARK = [
+    "▟██▛",
+    " ▜▙",
 ];
+/** Widest row of the mark, in cells (every mark glyph is single-cell). */
+export const STORM_MARK_WIDTH = Math.max(...STORM_MARK.map((line) => line.length));
+/** @deprecated Alias — the home panel uses {@link STORM_MARK}. */
+export const TORNADO_LOGO = STORM_MARK;
+/** @deprecated Alias. */
+export const TORNADO_LOGO_WIDTH = STORM_MARK_WIDTH;
+/** @deprecated Compact home is the full two-row mark. */
+export const TORNADO_LOGO_COMPACT = STORM_MARK;

package/dist/ui/present.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The only way a shell command may show a result and return to home.
+ * TTY: hold-to-read panel (q). Pipe: print the lines.
+ *
+ * Do not `console.log` then return from a shell command — the next
+ * askLine homes + ED 0 and wipes it. Live waits (login poll, review
+ * progress) may still write; the *final* result goes through here
+ * or through `openTabsBrowser`.
+ */
+export declare function present(title: string, lines: string[]): Promise<void>;

package/dist/ui/present.js

@@ -0,0 +1,13 @@
+import { showLinePanel } from "./line-tabs.js";
+/**
+ * The only way a shell command may show a result and return to home.
+ * TTY: hold-to-read panel (q). Pipe: print the lines.
+ *
+ * Do not `console.log` then return from a shell command — the next
+ * askLine homes + ED 0 and wipes it. Live waits (login poll, review
+ * progress) may still write; the *final* result goes through here
+ * or through `openTabsBrowser`.
+ */
+export async function present(title, lines) {
+    await showLinePanel(title, lines);
+}

package/dist/ui/prompt.d.ts

@@ -1,16 +1,164 @@
 export interface CommandSpec {
     name: string;
+    aliases?: string[];
     summary: string;
 }
 export interface AskLineOptions {
     prompt?: string;
     history?: string[];
     commands?: CommandSpec[];
+    /** Terminal rows; defaults to output.rows. Caps the slash viewport. */
+    rows?: number;
+    /**
+     * Terminal columns; defaults to output.columns, re-read on every render so
+     * a resize mid-prompt reflows the frame instead of smearing it.
+     */
+    columns?: number;
+    /** Streams (defaults: process.stdin / process.stdout). Injectable for tests. */
+    input?: NodeJS.ReadStream;
+    output?: NodeJS.WriteStream;
+    /**
+     * Welcome-panel rows sitting directly above this prompt, reflowed per
+     * width. Painted on every frame from the pane origin (`ESC[H`) so a
+     * resize cannot desync CUU counts. Pass `true` for compact, `"mini"` /
+     * `"nano"` for a short pane that still shows the mark.
+     */
+    header?: (columns?: number, variant?: boolean | "mini" | "nano") => string[];
 }
 /** Thrown when the user asks to close the prompt (Ctrl+D empty, or Ctrl+C twice). */
 export declare class PromptClosedError extends Error {
     constructor();
 }
+/**
+ * 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 declare function promptRedrawPrefix(inputRow: number): string;
+/**
+ * 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 declare function promptClearOverlay(boxed: boolean): string;
+/**
+ * Cursor home + ED 0: clears the whole screen from row 1 and leaves the
+ * cursor there. Used to redraw the welcome panel on resize, where the old
+ * frame's row count is unknowable after the terminal rewraps.
+ */
+export declare const HEADER_REDRAW_PREFIX = "\u001B[H\u001B[0J";
+export declare const DROPDOWN_MAX_COMMAND_ROWS = 8;
+export declare function formatSlashLabel(spec: CommandSpec): string;
+export declare function specMatchesTerm(spec: CommandSpec, term: string): boolean;
+export declare function slashToken(buffer: string): string | null;
+export declare function matchSlashCommands(buffer: string, specs: CommandSpec[], dismissed?: boolean): CommandSpec[];
+export declare function isExactSlashCommand(buffer: string, specs: CommandSpec[]): boolean;
+export declare function dropdownMaxRows(terminalRows: number | undefined, inputRow: number): number;
+export declare function dropdownViewport(count: number, index: number, maxRows: number): {
+    start: number;
+    moreAbove: number;
+    moreBelow: number;
+};
+export type OverlayRow = {
+    text: string;
+    selected?: boolean;
+};
+/** Overlay rows (no invert). At most `maxRows` commands plus edge markers. */
+/** Prompt label + input chrome + footer hint. */
+export declare function promptChromeRows(boxed: boolean, hasPrompt: boolean, hasHint?: boolean): number;
+/**
+ * Rows available above the input bar for the slash list. Idle home
+ * passes 0 — do not pad a blank gap between header and prompt.
+ */
+export declare function overlayReserve(terminalRows: number | undefined, headerRows: number, boxed: boolean, hasPrompt: boolean): number;
+/** Pad so the slash list sits just above the input bar (Claude-style). */
+export declare function padOverlayRows(rows: OverlayRow[], reserve: number): OverlayRow[];
+export interface HomeFrameFit {
+    header: string[];
+    reserve: number;
+    boxed: boolean;
+    hasPrompt: boolean;
+    hasHint: boolean;
+}
+/**
+ * Pick a header density and input chrome that fit the pane.
+ * Never drops the mark when a mini/nano header is provided — a short
+ * pane unboxes the input instead of painting an overflowing frame.
+ * `dockBottom` uses leftover rows so the prompt sits on the last lines.
+ */
+export declare function fitHomeFrame(params: {
+    fullHeader: string[];
+    compactHeader: string[];
+    miniHeader?: string[];
+    nanoHeader?: string[];
+    terminalRows: number | undefined;
+    boxed: boolean;
+    hasPrompt: boolean;
+    dropdownCount: number;
+    dockBottom?: boolean;
+}): HomeFrameFit;
+export declare function dropdownOverlayRows(dropdown: CommandSpec[], index: number, maxRows: number): OverlayRow[];
+/** Input prefix glyph (U+203A), kept as an escape so editors can't mangle it. */
+export declare const INPUT_PREFIX_GLYPH = "\u203A";
+/** Cells the `> ` prefix occupies before the buffer. */
+export declare const INPUT_PREFIX_CELLS = 2;
+/** Padding inside the boxed input frame. */
+export declare const INPUT_BOX_PADDING = 1;
+export interface InputWindow {
+    /** First buffer cell shown. */
+    start: number;
+    /** The visible slice of the buffer (ANSI-free, at most `cells` wide). */
+    text: string;
+    /** Cursor column within the window, 0-based. */
+    cursorCol: number;
+}
+/**
+ * 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 declare function inputWindow(buffer: string, cursor: number, cells: number, prevStart?: number): InputWindow;
+/** Cells available to the buffer (after the prefix) on a content row. */
+export declare function inputCells(columns: number | undefined, boxedOverride?: boolean): {
+    boxed: boolean;
+    cells: number;
+};
+export interface PromptFrameInput {
+    prompt?: string;
+    buffer: string;
+    cursor: number;
+    /** Terminal columns at draw time; undefined = unknown (boxed at 80). */
+    columns?: number;
+    /** Previous scroll origin, so left/right only move the window at the edges. */
+    scrollStart?: number;
+    overlay?: OverlayRow[];
+    /**
+     * When set, the overlay is padded to this many rows and drawn **above**
+     * the input bar. Height stays constant so `/` cannot scroll the header.
+     */
+    overlayReserve?: number;
+    /** Trailing footer row (empty or the Ctrl+C hint). */
+    hint?: string;
+    /** Welcome-panel rows painted with this frame (idle home screen). */
+    header?: string[];
+    /** Force boxed / plain input. Default follows {@link preferBoxedUi}. */
+    boxed?: boolean;
+}
+export interface PromptFrame {
+    rows: string[];
+    boxed: boolean;
+    /** Row (0-based) of the content line within `rows`. */
+    inputRow: number;
+    /** 1-based column to park the cursor on the content row. */
+    targetCol: number;
+    scrollStart: number;
+}
+/**
+ * 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 declare function buildPromptFrame(params: PromptFrameInput): PromptFrame;
 /**
  * Hand-rolled raw-mode line editor: bordered input box, history, and a live
  * slash-command dropdown. Falls back to plain readline on a non-TTY stream.