mergestorm 0.1.1 → 0.3.0

package/dist/shell.js

@@ -0,0 +1,183 @@
+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";
+import { cmdLogout } from "./commands/logout.js";
+import { cmdReview } from "./commands/review.js";
+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";
+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 printHelp() {
+    const rows = COMMANDS.map((c) => `  ${ansi.green("/" + c.name.padEnd(10))} ${c.summary}`).join("\n");
+    console.log(`
+  ${ansi.bold("Commands")}
+${rows}
+
+  Dashboard: https://mergestorm.ai/dashboard/api
+`);
+}
+/** 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+/);
+    const cmd = parts[0].toLowerCase();
+    return { cmd, args: parts.slice(1) };
+}
+export async function runShell() {
+    try {
+        await printBannerHeader();
+    }
+    catch { /* banner is best-effort */ }
+    const history = [];
+    let busyAbort = null;
+    let sigintHint = false;
+    const onSigint = () => {
+        if (busyAbort) {
+            busyAbort.abort();
+            return;
+        }
+        if (!sigintHint) {
+            output.write(`\n${ansi.dim("(type exit or press ctrl+d to quit)")}\n`);
+            sigintHint = true;
+        }
+        else {
+            output.write("\n");
+        }
+    };
+    process.on("SIGINT", onSigint);
+    try {
+        while (true) {
+            const cfg = await loadConfig();
+            const loggedIn = Boolean(resolveApiKey(cfg));
+            let line;
+            try {
+                line = await askLine({
+                    prompt: shellPrompt(loggedIn),
+                    history,
+                    commands: COMMANDS,
+                });
+            }
+            catch (err) {
+                if (err instanceof PromptClosedError) {
+                    console.log("");
+                    break;
+                }
+                throw err;
+            }
+            sigintHint = false;
+            const parsed = parseLine(line);
+            if (!parsed)
+                continue;
+            if (line.trim())
+                history.push(line);
+            const { cmd, args } = parsed;
+            if (cmd === "exit" || cmd === "quit")
+                break;
+            if (cmd === "help" || cmd === "?") {
+                printHelp();
+                continue;
+            }
+            if (cmd === "clear") {
+                output.write("");
+                try {
+                    await printBannerHeader();
+                }
+                catch { /* banner is best-effort */ }
+                continue;
+            }
+            busyAbort = new AbortController();
+            try {
+                if (cmd === "login") {
+                    await cmdLogin(args);
+                    await printBannerHeader();
+                }
+                else if (cmd === "logout") {
+                    await cmdLogout();
+                    await printBannerHeader();
+                }
+                else if (cmd === "review") {
+                    await cmdReview(args, { signal: busyAbort.signal, interactive: true });
+                }
+                else if (cmd === "status") {
+                    if (!args[0]) {
+                        throw new CommandError('usage: status <job_id>');
+                    }
+                    await cmdStatus(args[0], { format: "pretty", signal: busyAbort.signal });
+                }
+                else if (cmd === "credits" || cmd === "usage") {
+                    await cmdCredits(args);
+                }
+                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);
+                }
+                else if (cmd === "thread") {
+                    if (!args[0]) {
+                        throw new CommandError("usage: thread <slug>");
+                    }
+                    await cmdThread(args[0], args.slice(1));
+                }
+                else {
+                    console.error(ansi.dim(`unknown command "${cmd}" — type help`));
+                }
+            }
+            catch (err) {
+                if (err instanceof DetachedError) {
+                    console.log(`\n${ansi.yellow(err.message)}`);
+                }
+                else if (err instanceof CommandError) {
+                    console.error(ansi.red(err.message));
+                }
+                else if (err instanceof Error && err.name === "AbortError") {
+                    console.log(ansi.dim("\naborted"));
+                }
+                else {
+                    console.error(ansi.red(err instanceof Error ? err.message : String(err)));
+                }
+            }
+            finally {
+                busyAbort = null;
+            }
+        }
+    }
+    finally {
+        process.off("SIGINT", onSigint);
+    }
+}

package/dist/ui/ansi.d.ts

@@ -0,0 +1,12 @@
+export declare const ansi: {
+    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

@@ -0,0 +1,27 @@
+import { stdout } from "node:process";
+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 (!computeEnabled())
+        return text;
+    return `[${code}m${text}`;
+}
+export const ansi = {
+    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),
+    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

@@ -0,0 +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

@@ -0,0 +1,98 @@
+import { getMe } from "../api.js";
+import { keyDisplay, loadConfig, resolveApiKey } from "../config.js";
+import { cliVersion } from "../version.js";
+import { ansi } from "./ansi.js";
+import { roundedBox, 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("");
+}
+// 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": [
+        "Claude-style usage meter (N% used) + credit reset time",
+        "`branches` / `chain` — explore branch review timelines",
+    ],
+};
+function formatStatusLines(me, key) {
+    if (!key) {
+        return [
+            `${ansi.dim("○")} not logged in — type ${ansi.green("login")} to sign in via browser,`,
+            `  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)})`];
+    }
+    const plan = me.plan_label_key ?? me.plan_key;
+    const s = me.usage.standard;
+    // Compact Claude meter in the welcome panel (shorter than the credits view).
+    return [
+        `${ansi.green("●")} ${ansi.bold(display)}  ·  ${plan}`,
+        `  ${usageBar(s.used, s.limit, { width: 32 })}`,
+    ];
+}
+function tipsLines() {
+    return [
+        ansi.dim("Tips for getting started:"),
+        `  ${ansi.green("review")}      review the diff for main...HEAD`,
+        `  ${ansi.green("branches")}    pick a recently 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() {
+    const cfg = await loadConfig();
+    const key = resolveApiKey(cfg);
+    let me = null;
+    if (key) {
+        me = await getMe(cfg);
+    }
+    const version = cliVersion();
+    const textLines = [
+        ...formatStatusLines(me, key),
+        "",
+        ...tipsLines(),
+        ...whatsNewLines(version),
+    ];
+    const contentWidth = Math.max(0, ...textLines.map(visibleWidth), ...TORNADO_LOGO.map(visibleWidth));
+    const logoLines = TORNADO_LOGO.map((line) => centerLine(ansi.brightGreen(line), contentWidth));
+    const panel = roundedBox([...logoLines, "", ...textLines], {
+        title: `mergestorm v${version}`,
+    });
+    for (const line of panel) {
+        console.log(line);
+    }
+    console.log("");
+}
+export function shellPrompt(loggedIn) {
+    return loggedIn ? ansi.boldGreen("mergestorm") : ansi.dim("mergestorm");
+}

package/dist/ui/box.d.ts

@@ -0,0 +1,11 @@
+export declare function visibleWidth(str: string): number;
+export interface RoundedBoxOptions {
+    title?: string;
+    padding?: number;
+}
+/**
+ * Frames `lines` in a box sized to the widest visible line (ANSI-aware).
+ * Falls back to ASCII `+ - |` when color is disabled or TERM=dumb, since
+ * box-drawing glyphs can render incorrectly on such terminals.
+ */
+export declare function roundedBox(lines: string[], opts?: RoundedBoxOptions): string[];

package/dist/ui/box.js

@@ -0,0 +1,36 @@
+import { ansi } from "./ansi.js";
+const ANSI_PATTERN = /\[[0-9;]*m/g;
+export function visibleWidth(str) {
+    return str.replace(ANSI_PATTERN, "").length;
+}
+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 sized to the widest visible line (ANSI-aware).
+ * Falls back to ASCII `+ - |` when color is disabled or TERM=dumb, since
+ * box-drawing glyphs can render incorrectly on such terminals.
+ */
+export function roundedBox(lines, opts = {}) {
+    const padding = Math.max(0, opts.padding ?? 1);
+    const chars = boxChars();
+    const title = opts.title ? ` ${opts.title} ` : "";
+    const innerWidth = Math.max(0, ...lines.map(visibleWidth), visibleWidth(title)) + padding * 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];
+}

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 on an empty line). */
+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>;

package/dist/ui/prompt.js

@@ -0,0 +1,220 @@
+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 { roundedBox, visibleWidth } from "./box.js";
+/** Thrown when the user asks to close the prompt (Ctrl+D on an empty line). */
+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 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));
+            rows.push(...roundedBox([`${ansi.green("›")} ${buffer}`], { padding: 1 }));
+            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;
+                const dropdown = currentDropdown();
+                if (key.ctrl && key.name === "c") {
+                    buffer = "";
+                    cursor = 0;
+                    historyIndex = history.length;
+                    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>;