mergestorm 0.2.0 → 0.3.1

package/dist/ui/prompt.js

@@ -0,0 +1,237 @@
+import * as readline from "node:readline";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { ansi } from "./ansi.js";
+import { frameWidth, roundedBox, 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 {
+    constructor() {
+        super("prompt closed");
+        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 rl = createInterface({ input, output, terminal: false });
+    try {
+        return await rl.question(promptLabel ? `${promptLabel}> ` : "> ");
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * 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.
+ */
+export async function askLine(opts) {
+    const commands = opts.commands ?? [];
+    const history = opts.history ?? [];
+    if (!input.isTTY || !output.isTTY) {
+        return fallbackAskLine(opts.prompt);
+    }
+    return new Promise((resolve, reject) => {
+        let buffer = "";
+        let cursor = 0;
+        let historyIndex = history.length;
+        let dropdownIndex = 0;
+        let linesDrawn = 0;
+        let finished = false;
+        const ctrlCExit = new CtrlCExitGate();
+        const wasRaw = Boolean(input.isRaw);
+        readline.emitKeypressEvents(input);
+        input.setRawMode(true);
+        input.resume();
+        // Row (0-based) of the "› buffer" content line among the rows we draw each frame.
+        const inputRow = (opts.prompt ? 1 : 0) + 1;
+        function currentDropdown() {
+            if (!buffer.startsWith("/"))
+                return [];
+            const term = buffer.slice(1).toLowerCase();
+            return commands.filter((c) => c.name.toLowerCase().startsWith(term));
+        }
+        function render() {
+            if (linesDrawn > 0) {
+                output.write(`${up(inputRow)}${clearDown}`);
+            }
+            const rows = [];
+            if (opts.prompt)
+                rows.push(ansi.dim(opts.prompt));
+            // Full terminal width input frame, not content-sized.
+            rows.push(...roundedBox([`${ansi.green("›")} ${buffer}`], {
+                padding: 1,
+                width: frameWidth(),
+            }));
+            const dropdown = currentDropdown();
+            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));
+                });
+            }
+            else {
+                dropdownIndex = 0;
+            }
+            output.write(rows.join("\r\n") + "\r\n");
+            linesDrawn = rows.length;
+            const prefixWidth = visibleWidth(`${ansi.green("›")} `);
+            const targetCol = 1 + 1 + prefixWidth + cursor + 1;
+            output.write(`${up(linesDrawn - inputRow)}${col(targetCol)}`);
+        }
+        function cleanup() {
+            input.removeListener("keypress", onKeypress);
+            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.
+            input.pause();
+        }
+        function finish(value, err) {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            const rowsBelow = Math.max(0, linesDrawn - inputRow - 1);
+            if (rowsBelow > 0)
+                output.write(down(rowsBelow));
+            output.write("\n");
+            if (err)
+                reject(err);
+            else
+                resolve(value ?? "");
+        }
+        function acceptDropdown(dropdown) {
+            buffer = `/${dropdown[dropdownIndex].name} `;
+            cursor = buffer.length;
+            dropdownIndex = 0;
+        }
+        function onKeypress(str, key) {
+            try {
+                if (finished || !key)
+                    return;
+                if (!(key.ctrl && key.name === "c"))
+                    ctrlCExit.reset();
+                const dropdown = currentDropdown();
+                if (key.ctrl && key.name === "c") {
+                    if (ctrlCExit.press()) {
+                        finish(null, new PromptClosedError());
+                        return;
+                    }
+                    buffer = "";
+                    cursor = 0;
+                    historyIndex = history.length;
+                    const rowsBelow = Math.max(0, linesDrawn - inputRow - 1);
+                    if (rowsBelow > 0)
+                        output.write(down(rowsBelow));
+                    output.write(`\n${ansi.dim(CTRL_C_EXIT_HINT)}\n`);
+                    linesDrawn = 0;
+                    render();
+                    return;
+                }
+                if (key.ctrl && key.name === "d") {
+                    if (!buffer)
+                        finish(null, new PromptClosedError());
+                    return;
+                }
+                if (key.name === "return") {
+                    if (dropdown.length)
+                        buffer = `/${dropdown[dropdownIndex].name}`;
+                    finish(buffer);
+                    return;
+                }
+                if (key.name === "tab") {
+                    if (dropdown.length)
+                        acceptDropdown(dropdown);
+                    render();
+                    return;
+                }
+                if (key.name === "right") {
+                    if (dropdown.length)
+                        acceptDropdown(dropdown);
+                    else
+                        cursor = Math.min(buffer.length, cursor + 1);
+                    render();
+                    return;
+                }
+                if (key.name === "left") {
+                    cursor = Math.max(0, cursor - 1);
+                    render();
+                    return;
+                }
+                if (key.name === "up") {
+                    if (dropdown.length) {
+                        dropdownIndex = (dropdownIndex - 1 + dropdown.length) % dropdown.length;
+                    }
+                    else if (history.length) {
+                        historyIndex = Math.max(0, historyIndex - 1);
+                        buffer = history[historyIndex] ?? "";
+                        cursor = buffer.length;
+                    }
+                    render();
+                    return;
+                }
+                if (key.name === "down") {
+                    if (dropdown.length) {
+                        dropdownIndex = (dropdownIndex + 1) % dropdown.length;
+                    }
+                    else if (history.length) {
+                        historyIndex = Math.min(history.length, historyIndex + 1);
+                        buffer = historyIndex >= history.length ? "" : history[historyIndex] ?? "";
+                        cursor = buffer.length;
+                    }
+                    render();
+                    return;
+                }
+                if (key.name === "home" || (key.ctrl && key.name === "a")) {
+                    cursor = 0;
+                    render();
+                    return;
+                }
+                if (key.name === "end" || (key.ctrl && key.name === "e")) {
+                    cursor = buffer.length;
+                    render();
+                    return;
+                }
+                if (key.ctrl && key.name === "u") {
+                    buffer = buffer.slice(cursor);
+                    cursor = 0;
+                    render();
+                    return;
+                }
+                if (key.ctrl && key.name === "k") {
+                    buffer = buffer.slice(0, cursor);
+                    render();
+                    return;
+                }
+                if (key.name === "backspace") {
+                    if (cursor > 0) {
+                        buffer = 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);
+                    render();
+                    return;
+                }
+                if (str && !key.ctrl && !key.meta) {
+                    buffer = buffer.slice(0, cursor) + str + buffer.slice(cursor);
+                    cursor += str.length;
+                    render();
+                }
+            }
+            catch (err) {
+                finish(null, err);
+            }
+        }
+        input.on("keypress", onKeypress);
+        render();
+    });
+}

package/dist/ui/select.d.ts

@@ -0,0 +1,13 @@
+export type SelectOptions<T> = {
+    title?: string;
+    items: T[];
+    render: (item: T, index: number) => string;
+    /** Hint printed under the list (default: arrow/enter/esc keys). */
+    hint?: string;
+};
+/**
+ * Raw-mode arrow-key list selector (Claude-style). Returns the chosen item, or
+ * `null` if cancelled / empty. Non-TTY: prints a numbered list and returns null
+ * (caller should fall back to a table / prompt).
+ */
+export declare function selectFromList<T>(opts: SelectOptions<T>): Promise<T | null>;

package/dist/ui/select.js

@@ -0,0 +1,103 @@
+import * as readline from "node:readline";
+import { stdin as input, stdout as output } from "node:process";
+import { ansi } from "./ansi.js";
+const up = (n) => `\u001b[${n}A`;
+const clearDown = "\u001b[0J";
+/**
+ * Raw-mode arrow-key list selector (Claude-style). Returns the chosen item, or
+ * `null` if cancelled / empty. Non-TTY: prints a numbered list and returns null
+ * (caller should fall back to a table / prompt).
+ */
+export async function selectFromList(opts) {
+    const items = opts.items;
+    if (items.length === 0)
+        return null;
+    if (!input.isTTY || !output.isTTY) {
+        if (opts.title)
+            console.log(ansi.bold(`  ${opts.title}`));
+        items.forEach((item, i) => {
+            console.log(`  ${String(i + 1).padStart(2)}. ${opts.render(item, i)}`);
+        });
+        console.log(ansi.dim(opts.hint ?? "  (non-interactive — use `chain <slug>` or re-run on a TTY to select)"));
+        return null;
+    }
+    return new Promise((resolve) => {
+        let index = 0;
+        let linesDrawn = 0;
+        let finished = false;
+        const wasRaw = Boolean(input.isRaw);
+        readline.emitKeypressEvents(input);
+        input.setRawMode(true);
+        input.resume();
+        function render() {
+            if (linesDrawn > 0) {
+                output.write(`${up(linesDrawn)}${clearDown}`);
+            }
+            const rows = [];
+            if (opts.title)
+                rows.push(ansi.bold(opts.title));
+            items.forEach((item, i) => {
+                const body = opts.render(item, i);
+                const marker = i === index ? ansi.green("›") : " ";
+                const line = ` ${marker} ${body}`;
+                rows.push(i === index ? ansi.invert(line) : line);
+            });
+            rows.push(ansi.dim(opts.hint ?? "↑↓ navigate · enter select · esc cancel"));
+            output.write(rows.join("\r\n") + "\r\n");
+            linesDrawn = rows.length;
+        }
+        function cleanup() {
+            input.removeListener("keypress", onKeypress);
+            input.setRawMode(wasRaw);
+            input.pause();
+        }
+        function finish(value) {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            output.write("\n");
+            resolve(value);
+        }
+        function onKeypress(_str, key) {
+            if (finished || !key)
+                return;
+            if (key.name === "up") {
+                index = (index - 1 + items.length) % items.length;
+                try {
+                    render();
+                }
+                catch {
+                    finish(null);
+                }
+                return;
+            }
+            if (key.name === "down") {
+                index = (index + 1) % items.length;
+                try {
+                    render();
+                }
+                catch {
+                    finish(null);
+                }
+                return;
+            }
+            if (key.name === "return") {
+                finish(items[index]);
+                return;
+            }
+            if (key.name === "escape" ||
+                key.name === "q" ||
+                (key.ctrl && key.name === "c")) {
+                finish(null);
+            }
+        }
+        input.on("keypress", onKeypress);
+        try {
+            render();
+        }
+        catch {
+            finish(null);
+        }
+    });
+}

package/dist/ui/usage.d.ts

@@ -0,0 +1,24 @@
+export type UsageBarOpts = {
+    /** Bar width in cells (default 56). */
+    width?: number;
+    /** When false, return plain text with no ANSI (default: respect ansi.enabled). */
+    color?: boolean;
+};
+/**
+ * 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 == null` → "unlimited" (dev-bypass)
+ */
+export declare function usageBar(used: number, limit: number | null | undefined, opts?: UsageBarOpts): string;
+/** Start of the next UTC calendar month (matches API `resets_at`). */
+export declare function nextUtcMonthStart(now?: Date): string;
+/**
+ * Reset footer: `Resets Aug 1, 12:00am (UTC)`.
+ * Falls back to next UTC month start when `iso` is missing/invalid.
+ */
+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;

package/dist/ui/usage.js

@@ -0,0 +1,67 @@
+import { ansi } from "./ansi.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 == null` → "unlimited" (dev-bypass)
+ */
+export function usageBar(used, limit, opts = {}) {
+    const width = Math.max(8, opts.width ?? 56);
+    const color = opts.color ?? ansi.enabled;
+    if (limit == null) {
+        return color ? ansi.dim("unlimited") : "unlimited";
+    }
+    if (limit === 0) {
+        return color ? ansi.dim("not included") : "not included";
+    }
+    const safeUsed = Math.max(0, Number.isFinite(used) ? used : 0);
+    const ratio = Math.min(1, safeUsed / limit);
+    const filled = Math.round(ratio * width);
+    const empty = Math.max(0, width - filled);
+    const pct = Math.min(100, Math.round((safeUsed / limit) * 100));
+    // Filled segment colored; empty + label stay dim.
+    const filledSeg = "█".repeat(filled);
+    const emptySeg = "░".repeat(empty);
+    const suffix = ` ${pct}% used`;
+    if (!color) {
+        return `[${filledSeg}${emptySeg}]${suffix}`;
+    }
+    let fillColor = ansi.green;
+    if (ratio >= 0.9)
+        fillColor = ansi.red;
+    else if (ratio >= 0.75)
+        fillColor = ansi.yellow;
+    return (`[${fillColor(filledSeg)}${ansi.dim(emptySeg)}]` + ansi.dim(suffix));
+}
+/** Start of the next UTC calendar month (matches API `resets_at`). */
+export function nextUtcMonthStart(now = new Date()) {
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1)).toISOString();
+}
+/**
+ * Reset footer: `Resets Aug 1, 12:00am (UTC)`.
+ * Falls back to next UTC month start when `iso` is missing/invalid.
+ */
+export function formatResetLabel(iso, now = new Date()) {
+    const d = iso ? new Date(iso) : new Date(nextUtcMonthStart(now));
+    const when = Number.isNaN(d.getTime()) ? new Date(nextUtcMonthStart(now)) : d;
+    const months = [
+        "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+    ];
+    const month = months[when.getUTCMonth()];
+    const day = when.getUTCDate();
+    let h = when.getUTCHours();
+    const m = when.getUTCMinutes();
+    const ampm = h >= 12 ? "pm" : "am";
+    h = h % 12;
+    if (h === 0)
+        h = 12;
+    const mm = String(m).padStart(2, "0");
+    return `Resets ${month} ${day}, ${h}:${mm}${ampm} (UTC)`;
+}
+/** Alias kept for callers that still import `formatResetDate`. */
+export function formatResetDate(iso) {
+    return formatResetLabel(iso);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mergestorm",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "MergeStorm CLI — interactive shell and one-shot review commands",
   "type": "module",
   "bin": {
@@ -19,10 +19,11 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.build.json",
     "dev": "tsx src/cli.ts",
     "start": "node dist/cli.js",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "tsx --test src/**/*.test.ts"
   },
   "engines": {
     "node": ">=22.0.0"