mergestorm 0.2.0 → 0.3.1

package/dist/shell.js

@@ -1,7 +1,7 @@
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
+import { stdout as output } from "node:process";
 import { loadConfig, resolveApiKey } from "./config.js";
 import { CommandError, DetachedError } from "./errors.js";
+import { cmdBranches, cmdChain } from "./commands/branches.js";
 import { cmdCredits } from "./commands/credits.js";
 import { cmdJobs, cmdThread } from "./commands/jobs.js";
 import { cmdLogin } from "./commands/login.js";
@@ -11,45 +11,42 @@ import { cmdStatus } from "./commands/status.js";
 import { cmdWhoami } from "./commands/whoami.js";
 import { ansi } from "./ui/ansi.js";
 import { printBannerHeader, shellPrompt } from "./ui/banner.js";
-const COMMANDS = [
-    "help",
-    "login",
-    "logout",
-    "review",
-    "status",
-    "credits",
-    "usage",
-    "jobs",
-    "whoami",
-    "thread",
-    "clear",
-    "exit",
-    "quit",
+import { CTRL_C_EXIT_HINT, CtrlCExitGate } from "./ui/ctrl-c-exit.js";
+import { askLine, PromptClosedError } from "./ui/prompt.js";
+export const COMMANDS = [
+    { name: "help", summary: "Show available commands" },
+    { name: "login", summary: "Sign in via browser (or paste a key)" },
+    { name: "logout", summary: "Remove the stored API key" },
+    { name: "review", summary: "Review git diff (default main...HEAD)" },
+    { name: "status", summary: "Show a review job" },
+    { name: "credits", summary: "Credit balance with usage bars" },
+    { name: "usage", summary: "Credit balance with usage bars" },
+    { name: "jobs", summary: "Recent review jobs (default 10)" },
+    { name: "branches", summary: "Pick a recently reviewed branch" },
+    { name: "chains", summary: "Alias for branches" },
+    { name: "chain", summary: "Show a branch review-chain timeline" },
+    { name: "whoami", summary: "Key + plan + API base" },
+    { name: "thread", summary: "Jobs in a review thread" },
+    { name: "clear", summary: "Clear screen and reprint banner" },
+    { name: "exit", summary: "Leave the shell" },
+    { name: "quit", summary: "Leave the shell" },
 ];
-function completer(line) {
-    const hits = COMMANDS.filter((c) => c.startsWith(line));
-    return [hits.length ? [...hits] : [...COMMANDS], line];
-}
 function printHelp() {
+    const rows = COMMANDS.map((c) => `  ${ansi.green("/" + c.name.padEnd(10))} ${c.summary}`).join("\n");
     console.log(`
   ${ansi.bold("Commands")}
-  login [--key]          Sign in via browser (or paste a key)
-  logout                 Remove the stored API key
-  review [base] [head]   Review git diff (default main...HEAD)
-  status <job_id>        Show a review job
-  credits / usage        Credit balance
-  jobs [n]               Recent review jobs (default 10)
-  whoami                 Key + plan + API base
-  thread <slug>          Jobs in a review thread
-  clear                  Clear screen and reprint banner
-  help                   This help
-  exit / quit            Leave the shell
+${rows}
 
   Dashboard: https://mergestorm.ai/dashboard/api
 `);
 }
-function parseLine(line) {
-    const trimmed = line.trim();
+/** Strips an optional leading "/" so both "review" and "/review" work. */
+export function parseLine(line) {
+    let trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("/"))
+        trimmed = trimmed.slice(1).trim();
     if (!trimmed)
         return null;
     const parts = trimmed.split(/\s+/);
@@ -61,53 +58,54 @@ export async function runShell() {
         await printBannerHeader();
     }
     catch { /* banner is best-effort */ }
-    const rl = createInterface({
-        input,
-        output,
-        completer,
-        historySize: 200,
-        terminal: Boolean(output.isTTY),
-    });
+    const history = [];
     let busyAbort = null;
-    let sigintHint = false;
-    let sigintDuringPrompt = false;
+    const idleCtrlC = new CtrlCExitGate();
+    let exiting = false;
     const onSigint = () => {
-        sigintDuringPrompt = true;
+        // Busy commands: first Ctrl+C aborts/detaches only -- never exit the shell.
+        // Exit confirm is for the idle prompt (see askLine); do not arm idleCtrlC here.
         if (busyAbort) {
             busyAbort.abort();
             return;
         }
-        if (!sigintHint) {
-            output.write(`\n${ansi.dim("(type exit or press ctrl+d to quit)")}\n`);
-            sigintHint = true;
-        }
-        else {
+        // Rare path: SIGINT outside raw-mode prompt (e.g. between turns).
+        // Idle TTY Ctrl+C is handled in askLine as a keypress.
+        if (idleCtrlC.press()) {
             output.write("\n");
+            exiting = true;
+            return;
         }
+        output.write(`\n${ansi.dim(CTRL_C_EXIT_HINT)}\n`);
     };
     process.on("SIGINT", onSigint);
     try {
         while (true) {
-            sigintDuringPrompt = false;
             const cfg = await loadConfig();
             const loggedIn = Boolean(resolveApiKey(cfg));
+            if (exiting)
+                break;
             let line;
             try {
-                line = await rl.question(shellPrompt(loggedIn));
+                line = await askLine({
+                    prompt: shellPrompt(loggedIn),
+                    history,
+                    commands: COMMANDS,
+                });
             }
-            catch {
-                if (sigintDuringPrompt) {
-                    sigintDuringPrompt = false;
-                    continue;
+            catch (err) {
+                if (err instanceof PromptClosedError) {
+                    console.log("");
+                    break;
                 }
-                // Ctrl+D / closed
-                console.log("");
-                break;
+                throw err;
             }
-            sigintHint = false;
+            idleCtrlC.reset();
             const parsed = parseLine(line);
             if (!parsed)
                 continue;
+            if (line.trim())
+                history.push(line);
             const { cmd, args } = parsed;
             if (cmd === "exit" || cmd === "quit")
                 break;
@@ -116,7 +114,7 @@ export async function runShell() {
                 continue;
             }
             if (cmd === "clear") {
-                output.write("\u001b[2J\u001b[H");
+                output.write("");
                 try {
                     await printBannerHeader();
                 }
@@ -126,7 +124,7 @@ export async function runShell() {
             busyAbort = new AbortController();
             try {
                 if (cmd === "login") {
-                    await cmdLogin(args, rl);
+                    await cmdLogin(args);
                     await printBannerHeader();
                 }
                 else if (cmd === "logout") {
@@ -148,6 +146,12 @@ export async function runShell() {
                 else if (cmd === "jobs") {
                     await cmdJobs(args);
                 }
+                else if (cmd === "branches" || cmd === "chains") {
+                    await cmdBranches(args);
+                }
+                else if (cmd === "chain") {
+                    await cmdChain(args);
+                }
                 else if (cmd === "whoami") {
                     await cmdWhoami(args);
                 }
@@ -158,7 +162,7 @@ export async function runShell() {
                     await cmdThread(args[0], args.slice(1));
                 }
                 else {
-                    console.error(ansi.dim(`unknown command "${cmd}" — type help`));
+                    console.error(ansi.dim(`unknown command "${cmd}" -- type help`));
                 }
             }
             catch (err) {
@@ -182,6 +186,5 @@ export async function runShell() {
     }
     finally {
         process.off("SIGINT", onSigint);
-        rl.close();
     }
 }

package/dist/ui/ansi.d.ts

@@ -1,9 +1,12 @@
 export declare const ansi: {
-    enabled: boolean;
+    readonly enabled: boolean;
     green: (t: string) => string;
     bold: (t: string) => string;
     dim: (t: string) => string;
     red: (t: string) => string;
     yellow: (t: string) => string;
+    gray: (t: string) => string;
+    brightGreen: (t: string) => string;
+    invert: (t: string) => string;
     boldGreen: (t: string) => string;
 };

package/dist/ui/ansi.js

@@ -1,20 +1,27 @@
 import { stdout } from "node:process";
-const enabled = process.env.FORCE_COLOR !== undefined && process.env.FORCE_COLOR !== "0"
-    ? true
-    : Boolean(stdout.isTTY) &&
-        !process.env.NO_COLOR &&
-        process.env.TERM !== "dumb";
+function computeEnabled() {
+    return process.env.FORCE_COLOR !== undefined && process.env.FORCE_COLOR !== "0"
+        ? true
+        : Boolean(stdout.isTTY) &&
+            !process.env.NO_COLOR &&
+            process.env.TERM !== "dumb";
+}
 function wrap(code, text) {
-    if (!enabled)
+    if (!computeEnabled())
         return text;
-    return `\u001b[${code}m${text}\u001b[0m`;
+    return `[${code}m${text}`;
 }
 export const ansi = {
-    enabled,
+    get enabled() {
+        return computeEnabled();
+    },
     green: (t) => wrap("32", t),
     bold: (t) => wrap("1", t),
     dim: (t) => wrap("2", t),
     red: (t) => wrap("31", t),
     yellow: (t) => wrap("33", t),
-    boldGreen: (t) => (enabled ? `\u001b[1;32m${t}\u001b[0m` : t),
+    gray: (t) => wrap("90", t),
+    brightGreen: (t) => wrap("92", t),
+    invert: (t) => wrap("7", t),
+    boldGreen: (t) => (computeEnabled() ? `${t}` : t),
 };

package/dist/ui/banner.d.ts

@@ -1,3 +1,4 @@
+/** Used by the non-interactive `usage()` path in cli.ts — the boxed banner is shell-only. */
 export declare function printWordmark(): void;
 export declare function printBannerHeader(): Promise<void>;
 export declare function shellPrompt(loggedIn: boolean): string;

package/dist/ui/banner.js

@@ -2,46 +2,116 @@ import { getMe } from "../api.js";
 import { keyDisplay, loadConfig, resolveApiKey } from "../config.js";
 import { cliVersion } from "../version.js";
 import { ansi } from "./ansi.js";
+import { frameWidth, padVisible, roundedBox, sideBySide, visibleWidth, } from "./box.js";
+import { TORNADO_LOGO } from "./logo.js";
+import { usageBar } from "./usage.js";
 const WORDMARK = `
  __  __ ___ ___  ___ ___ ___ _____ ___  ___ __  __
 |  \\/  | __| _ \\/ __| __/ __|_   _/ _ \\| _ \\  \\/  |
 | |\\/| | _||   / (_ | _|\\__ \\ | || (_) |   / |\\/| |
 |_|  |_|___|_|_\\\\___|___|___/ |_| \\___/|_|_\\_|  |_|
 `.trimEnd();
+/** Used by the non-interactive `usage()` path in cli.ts — the boxed banner is shell-only. */
 export function printWordmark() {
     console.log(ansi.boldGreen(WORDMARK));
     console.log(ansi.dim(`  review local diffs fast · mergestorm.ai · v${cliVersion()}`));
     console.log("");
 }
-function formatStatusLine(me, key) {
+// Keyed by CLI version so the banner surfaces exactly what shipped in that release.
+const WHATS_NEW = {
+    "0.2.0": [
+        "Boxed welcome banner with a fresh look",
+        "Live `/` slash-command autocomplete in the shell",
+    ],
+    "0.3.0": [
+        "Usage meter (N% used) + credit reset time",
+        "`branches` / `chain` — explore branch review timelines",
+    ],
+    "0.3.1": [
+        "Full-width welcome panel + input (matches terminal columns)",
+        "Two-column layout: status left, tips/what's new right",
+        "Ctrl+C twice at the prompt to exit",
+    ],
+};
+function formatStatusLines(me, key, barWidth) {
     if (!key) {
-        return (`  ${ansi.dim("○")} not logged in — type ${ansi.green("login")} to sign in via browser,\n` +
-            `    or ${ansi.green("login --key")} to paste an API key`);
+        return [
+            `${ansi.dim("○")} not logged in — type ${ansi.green("login")} to sign in`,
+            `  or ${ansi.green("login --key")} to paste an API key`,
+        ];
     }
     const display = me?.key.prefix ?? keyDisplay(key) ?? "msk_live_…";
     if (!me) {
-        return `  ${ansi.green("●")} logged in (${ansi.bold(display)})`;
+        return [`${ansi.green("●")} logged in (${ansi.bold(display)})`];
     }
     const plan = me.plan_label_key ?? me.plan_key;
-    const left = me.usage.standard.remaining;
-    const limit = me.usage.standard.limit;
-    return (`  ${ansi.green("●")} ${ansi.bold(display)}  ·  ${plan}  ·  ` +
-        `standard credits: ${left} of ${limit} left`);
+    const s = me.usage.standard;
+    return [
+        `${ansi.green("●")} ${ansi.bold(display)}  ·  ${plan}`,
+        usageBar(s.used, s.limit, { width: barWidth }),
+    ];
+}
+function tipsLines() {
+    return [
+        ansi.dim("Tips for getting started"),
+        `  ${ansi.green("review")}      review main...HEAD`,
+        `  ${ansi.green("branches")}    pick a reviewed branch`,
+        `  ${ansi.green("/help")}       list all commands`,
+    ];
+}
+function whatsNewLines(version) {
+    const entries = WHATS_NEW[version];
+    if (!entries || !entries.length)
+        return [];
+    return [
+        ansi.dim(`What's new in v${version}`),
+        ...entries.map((entry) => `  ${ansi.green("•")} ${entry}`),
+    ];
+}
+function centerLine(line, width) {
+    const room = Math.max(0, width - visibleWidth(line));
+    const left = Math.floor(room / 2);
+    return `${" ".repeat(left)}${line}${" ".repeat(room - left)}`;
 }
 export async function printBannerHeader() {
-    printWordmark();
     const cfg = await loadConfig();
     const key = resolveApiKey(cfg);
     let me = null;
     if (key) {
         me = await getMe(cfg);
     }
-    console.log(formatStatusLine(me, key));
-    console.log("");
-    console.log(ansi.dim("  type `help` for commands · `review` to review main...HEAD"));
+    const version = cliVersion();
+    const outer = frameWidth();
+    // Inner content width inside the box (borders + padding).
+    const inner = Math.max(40, outer - 4);
+    // Two columns: left = logo + status, right = tips + what's new.
+    const leftColW = Math.max(28, Math.floor(inner * 0.42));
+    const rightColW = Math.max(24, inner - leftColW - 2);
+    const barWidth = Math.max(12, leftColW - 4);
+    const logoLines = TORNADO_LOGO.map((line) => centerLine(ansi.brightGreen(line), leftColW));
+    const leftCol = [
+        ...logoLines,
+        "",
+        ...formatStatusLines(me, key, barWidth),
+    ];
+    const rightCol = [
+        ...tipsLines(),
+        "",
+        ...whatsNewLines(version),
+    ];
+    // Clip right column lines that overflow the right pane.
+    const rightClipped = rightCol.map((line) => visibleWidth(line) <= rightColW ? line : padVisible(line, rightColW));
+    const rows = sideBySide(leftCol, rightClipped, leftColW, 2);
+    const panel = roundedBox(rows, {
+        title: `mergestorm v${version}`,
+        width: outer,
+        padding: 1,
+    });
+    for (const line of panel) {
+        console.log(line);
+    }
     console.log("");
 }
 export function shellPrompt(loggedIn) {
-    const name = loggedIn ? ansi.boldGreen("mergestorm") : ansi.dim("mergestorm");
-    return `${name}> `;
+    return loggedIn ? ansi.boldGreen("mergestorm") : ansi.dim("mergestorm");
 }

package/dist/ui/box.d.ts

@@ -0,0 +1,31 @@
+export declare function visibleWidth(str: string): number;
+/** Usable terminal columns (TTY), with a sensible fallback for pipes/tests. */
+export declare function terminalColumns(fallback?: number): number;
+/**
+ * Outer box width for Claude-style full-bleed frames.
+ * Leaves 1 col margin so the right border doesn't wrap.
+ */
+export declare function frameWidth(fallback?: number): number;
+export interface RoundedBoxOptions {
+    title?: string;
+    padding?: number;
+    /**
+     * Exact outer width (including borders). When set, content is padded to fill.
+     * Prefer this for full-width Claude-style frames.
+     */
+    width?: number;
+    /** Grow to at least this outer width (content may still be wider). */
+    minWidth?: number;
+}
+/**
+ * Frames `lines` in a box. By default sized to content; pass `width` /
+ * `minWidth` to stretch to the terminal like Claude Code.
+ */
+export declare function roundedBox(lines: string[], opts?: RoundedBoxOptions): string[];
+/** Pad/truncate a line to an exact visible width (ANSI-safe). */
+export declare function padVisible(line: string, width: number): string;
+/**
+ * Join left/right columns into rows of equal left-column width.
+ * Extra rows on either side are blank-padded.
+ */
+export declare function sideBySide(left: string[], right: string[], leftWidth: number, gap?: number): string[];

package/dist/ui/box.js

@@ -0,0 +1,99 @@
+import { stdout } from "node:process";
+import { ansi } from "./ansi.js";
+const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
+export function visibleWidth(str) {
+    return str.replace(ANSI_PATTERN, "").length;
+}
+/** Usable terminal columns (TTY), with a sensible fallback for pipes/tests. */
+export function terminalColumns(fallback = 80) {
+    const cols = stdout.columns;
+    if (typeof cols === "number" && Number.isFinite(cols) && cols >= 40) {
+        return cols;
+    }
+    return fallback;
+}
+/**
+ * Outer box width for Claude-style full-bleed frames.
+ * Leaves 1 col margin so the right border doesn't wrap.
+ */
+export function frameWidth(fallback = 80) {
+    return Math.max(48, terminalColumns(fallback) - 1);
+}
+const ROUNDED = { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" };
+const ASCII = { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" };
+function boxChars() {
+    return !ansi.enabled || process.env.TERM === "dumb" ? ASCII : ROUNDED;
+}
+function centerLabel(label, width, fill) {
+    const room = Math.max(0, width - visibleWidth(label));
+    const left = Math.floor(room / 2);
+    const right = room - left;
+    return `${fill.repeat(left)}${label}${fill.repeat(right)}`;
+}
+/**
+ * Frames `lines` in a box. By default sized to content; pass `width` /
+ * `minWidth` to stretch to the terminal like Claude Code.
+ */
+export function roundedBox(lines, opts = {}) {
+    const padding = Math.max(0, opts.padding ?? 1);
+    const chars = boxChars();
+    const title = opts.title ? ` ${opts.title} ` : "";
+    const contentInner = Math.max(0, ...lines.map(visibleWidth), visibleWidth(title)) + padding * 2;
+    let innerWidth = contentInner;
+    if (opts.width !== undefined) {
+        // outer = inner + 2 border cols
+        innerWidth = Math.max(contentInner, opts.width - 2);
+    }
+    else if (opts.minWidth !== undefined) {
+        innerWidth = Math.max(contentInner, opts.minWidth - 2);
+    }
+    const top = ansi.gray(title
+        ? `${chars.tl}${centerLabel(title, innerWidth, chars.h)}${chars.tr}`
+        : `${chars.tl}${chars.h.repeat(innerWidth)}${chars.tr}`);
+    const bottom = ansi.gray(`${chars.bl}${chars.h.repeat(innerWidth)}${chars.br}`);
+    const body = lines.map((line) => {
+        const gap = Math.max(0, innerWidth - padding - visibleWidth(line));
+        return `${ansi.gray(chars.v)}${" ".repeat(padding)}${line}${" ".repeat(gap)}${ansi.gray(chars.v)}`;
+    });
+    return [top, ...body, bottom];
+}
+/** Pad/truncate a line to an exact visible width (ANSI-safe). */
+export function padVisible(line, width) {
+    const w = visibleWidth(line);
+    if (w === width)
+        return line;
+    if (w < width)
+        return `${line}${" ".repeat(width - w)}`;
+    // Truncate while preserving ANSI codes: walk the string counting only
+    // visible characters, then slice the original at that position.
+    let visible = 0;
+    let i = 0;
+    const re = /\u001b\[[0-9;]*m/g;
+    while (visible < width && i < line.length) {
+        re.lastIndex = i;
+        const m = re.exec(line);
+        if (m && m.index === i) {
+            i = re.lastIndex;
+        }
+        else {
+            const code = line.charCodeAt(i);
+            i += code >= 0xd800 && code <= 0xdbff ? 2 : 1;
+            visible++;
+        }
+    }
+    return line.slice(0, i);
+}
+/**
+ * Join left/right columns into rows of equal left-column width.
+ * Extra rows on either side are blank-padded.
+ */
+export function sideBySide(left, right, leftWidth, gap = 2) {
+    const rows = Math.max(left.length, right.length);
+    const out = [];
+    for (let i = 0; i < rows; i++) {
+        const L = padVisible(left[i] ?? "", leftWidth);
+        const R = right[i] ?? "";
+        out.push(`${L}${" ".repeat(gap)}${R}`);
+    }
+    return out;
+}

package/dist/ui/ctrl-c-exit.d.ts

@@ -0,0 +1,13 @@
+/** Window (ms) for a second Ctrl+C to confirm shell exit. */
+export declare const CTRL_C_CONFIRM_MS = 1500;
+/**
+ * Tracks consecutive Ctrl+C presses. First press arms a confirm window;
+ * a second press within {@link CTRL_C_CONFIRM_MS} means exit.
+ */
+export declare class CtrlCExitGate {
+    private lastAt;
+    /** @returns true when the caller should exit the shell */
+    press(now?: number): boolean;
+    reset(): void;
+}
+export declare const CTRL_C_EXIT_HINT = "Press Ctrl+C again to exit";

package/dist/ui/ctrl-c-exit.js

@@ -0,0 +1,22 @@
+/** Window (ms) for a second Ctrl+C to confirm shell exit. */
+export const CTRL_C_CONFIRM_MS = 1500;
+/**
+ * Tracks consecutive Ctrl+C presses. First press arms a confirm window;
+ * a second press within {@link CTRL_C_CONFIRM_MS} means exit.
+ */
+export class CtrlCExitGate {
+    lastAt = 0;
+    /** @returns true when the caller should exit the shell */
+    press(now = Date.now()) {
+        if (this.lastAt > 0 && now - this.lastAt <= CTRL_C_CONFIRM_MS) {
+            this.lastAt = 0;
+            return true;
+        }
+        this.lastAt = now;
+        return false;
+    }
+    reset() {
+        this.lastAt = 0;
+    }
+}
+export const CTRL_C_EXIT_HINT = "Press Ctrl+C again to exit";

package/dist/ui/logo.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pixelated funnel logo, colored by the caller (see banner.ts).
+ * Kept as plain glyphs here so consumers can measure/center it with visibleWidth.
+ */
+export declare const TORNADO_LOGO: string[];

package/dist/ui/logo.js

@@ -0,0 +1,12 @@
+/**
+ * Pixelated funnel logo, colored by the caller (see banner.ts).
+ * Kept as plain glyphs here so consumers can measure/center it with visibleWidth.
+ */
+export const TORNADO_LOGO = [
+    "▟██████████▛",
+    " ▜████████▛",
+    "  ▝▜████▛▘",
+    "    ▜██▛",
+    "     ██",
+    "     ▝▘",
+];

package/dist/ui/prompt.d.ts

@@ -0,0 +1,18 @@
+export interface CommandSpec {
+    name: string;
+    summary: string;
+}
+export interface AskLineOptions {
+    prompt?: string;
+    history?: string[];
+    commands?: CommandSpec[];
+}
+/** Thrown when the user asks to close the prompt (Ctrl+D empty, or Ctrl+C twice). */
+export declare class PromptClosedError extends Error {
+    constructor();
+}
+/**
+ * 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 declare function askLine(opts: AskLineOptions): Promise<string>;