mergestorm 0.3.9 → 0.3.13

package/dist/submit-pr-base.d.ts

@@ -0,0 +1,31 @@
+/**
+ * GitHub PR base for `stack submit` (#1104).
+ *
+ * Git parent stays the previous layer (local rebase / `--onto`). Position 3+
+ * must open onto the review-unit park freeze so adopt does not retarget after
+ * `opened` and double-wake Vortex.
+ */
+import type { StackDto } from "./api.js";
+export declare const MG_PARK_PREFIX = "mg-park-";
+export declare function isMgParkBranch(branch: string): boolean;
+/** Live freeze already used as a GitHub base on this stack, if any. */
+export declare function parkFreezeBranchFromStack(stack: StackDto): string | null;
+export type SubmitLayerPlan = {
+    branch: string;
+    gitParent: string;
+    position: number;
+    /** GitHub `--base` when known. `null` means mint the freeze first. */
+    githubBase: string | null;
+    needsPark: boolean;
+    stackId: string | null;
+};
+export declare function planSubmitLayerBases(input: {
+    layers: readonly {
+        branch: string;
+        parentBranch: string;
+    }[];
+    trunk: string;
+    registered: readonly StackDto[];
+    owner: string;
+    repo: string;
+}): SubmitLayerPlan[];

package/dist/submit-pr-base.js

@@ -0,0 +1,69 @@
+function registeredParentHit(stacks, parentBranch, owner, repo) {
+    const want = parentBranch.trim();
+    if (!want)
+        return null;
+    for (const stack of stacks) {
+        if (stack.owner !== owner || stack.repo !== repo)
+            continue;
+        for (const layer of stack.layers) {
+            if (layer.branch === want) {
+                return { stackId: stack.id, position: layer.position };
+            }
+        }
+    }
+    return null;
+}
+export const MG_PARK_PREFIX = "mg-park-";
+export function isMgParkBranch(branch) {
+    return branch.trim().toLowerCase().startsWith(MG_PARK_PREFIX);
+}
+/** Live freeze already used as a GitHub base on this stack, if any. */
+export function parkFreezeBranchFromStack(stack) {
+    for (const layer of stack.layers) {
+        const parent = layer.parentBranch?.trim() ?? "";
+        if (isMgParkBranch(parent))
+            return parent;
+    }
+    return null;
+}
+export function planSubmitLayerBases(input) {
+    const { layers, trunk, registered, owner, repo } = input;
+    const localIndex = new Map(layers.map((layer, i) => [layer.branch, i]));
+    const plans = [];
+    for (let i = 0; i < layers.length; i++) {
+        const layer = layers[i];
+        const gitParent = layer.parentBranch.trim() || trunk;
+        const priorLocal = localIndex.get(gitParent);
+        let position;
+        let stackId = null;
+        if (priorLocal !== undefined && plans[priorLocal]) {
+            position = plans[priorLocal].position + 1;
+            stackId = plans[priorLocal].stackId;
+        }
+        else {
+            const hit = registeredParentHit(registered, gitParent, owner, repo);
+            if (hit) {
+                position = hit.position + 1;
+                stackId = hit.stackId;
+            }
+            else {
+                position = 1;
+            }
+        }
+        const stack = stackId
+            ? registered.find((row) => row.id === stackId) ?? null
+            : null;
+        const existingPark = stack ? parkFreezeBranchFromStack(stack) : null;
+        const needsPark = position >= 3;
+        const githubBase = needsPark ? existingPark : gitParent;
+        plans.push({
+            branch: layer.branch,
+            gitParent,
+            position,
+            githubBase,
+            needsPark,
+            stackId,
+        });
+    }
+    return plans;
+}

package/dist/ui/banner.js

@@ -66,6 +66,13 @@ const WHATS_NEW = {
         "npm description points at MIT build-from-source URL",
         "Dashboard links → Settings → API / Work (product URL cleanup)",
     ],
+    "0.3.10": [
+        "README: verify public git SHA + npm integrity (build from mergestorm-cli)",
+    ],
+    "0.3.12": [
+        "review --router off|standard|max|manual (same smart router as Agents)",
+        "review --specialists security,frontend,… to pin or invoke lanes",
+    ],
 };
 function formatStatusLines(me, key, barWidth, keyInvalid = false) {
     if (!key) {

package/dist/ui/box.d.ts

@@ -1,24 +1,30 @@
-export declare function visibleWidth(str: string): number;
+import { padVisible, sliceVisible, visibleWidth } from "./width.js";
+export { padVisible, sliceVisible, visibleWidth };
 /** Below this width, boxed chrome wraps on real TTYs — prefer plain output. */
 export declare const MIN_BOXED_COLUMNS = 48;
-/** Usable terminal columns (TTY), with a sensible fallback for pipes/tests. */
-export declare function terminalColumns(fallback?: number): number;
+/**
+ * Usable terminal columns (TTY), with a sensible fallback for pipes/tests.
+ * Pass `columns` to measure a stream other than process.stdout (or a
+ * post-resize value); `undefined` reads stdout at call time.
+ */
+export declare function terminalColumns(fallback?: number, columns?: number): number;
 /**
  * Whether rounded/full-bleed boxes fit without wrapping.
  * Non-TTY (unknown columns) keeps boxes for tests and CI logs.
  */
-export declare function preferBoxedUi(): boolean;
+export declare function preferBoxedUi(columns?: number): boolean;
 /**
  * Outer box width for Claude-style full-bleed frames.
  * Never wider than the terminal (minus 1 so the right border doesn't wrap).
  */
-export declare function frameWidth(fallback?: number): number;
+export declare function frameWidth(fallback?: number, columns?: 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.
+     * Exact outer width (including borders). When set, content is padded to
+     * fill and *clipped* to fit: no row is ever wider than this, because a row
+     * that wraps is a row the redraw math doesn't know about.
      */
     width?: number;
     /** Grow to at least this outer width (content may still be wider). */
@@ -29,8 +35,6 @@ export interface RoundedBoxOptions {
  * `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.

package/dist/ui/box.js

@@ -1,14 +1,18 @@
 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;
-}
+import { padVisible, sliceVisible, visibleWidth } from "./width.js";
+// Cell arithmetic lives in width.ts; re-exported so existing `./box.js`
+// importers (banner, prompt) keep working.
+export { padVisible, sliceVisible, visibleWidth };
 /** Below this width, boxed chrome wraps on real TTYs — prefer plain output. */
 export const MIN_BOXED_COLUMNS = 48;
-/** Usable terminal columns (TTY), with a sensible fallback for pipes/tests. */
-export function terminalColumns(fallback = 80) {
-    const cols = stdout.columns;
+/**
+ * Usable terminal columns (TTY), with a sensible fallback for pipes/tests.
+ * Pass `columns` to measure a stream other than process.stdout (or a
+ * post-resize value); `undefined` reads stdout at call time.
+ */
+export function terminalColumns(fallback = 80, columns) {
+    const cols = columns ?? stdout.columns;
     if (typeof cols === "number" && Number.isFinite(cols) && cols >= 1) {
         return cols;
     }
@@ -18,8 +22,8 @@ export function terminalColumns(fallback = 80) {
  * Whether rounded/full-bleed boxes fit without wrapping.
  * Non-TTY (unknown columns) keeps boxes for tests and CI logs.
  */
-export function preferBoxedUi() {
-    const cols = stdout.columns;
+export function preferBoxedUi(columns) {
+    const cols = columns ?? stdout.columns;
     if (typeof cols !== "number" || !Number.isFinite(cols))
         return true;
     return cols >= MIN_BOXED_COLUMNS;
@@ -28,8 +32,8 @@ export function preferBoxedUi() {
  * Outer box width for Claude-style full-bleed frames.
  * Never wider than the terminal (minus 1 so the right border doesn't wrap).
  */
-export function frameWidth(fallback = 80) {
-    return Math.max(20, terminalColumns(fallback) - 1);
+export function frameWidth(fallback = 80, columns) {
+    return Math.max(20, terminalColumns(fallback, columns) - 1);
 }
 const ROUNDED = { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" };
 const ASCII = { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|" };
@@ -49,12 +53,17 @@ function centerLabel(label, width, fill) {
 export function roundedBox(lines, opts = {}) {
     const padding = Math.max(0, opts.padding ?? 1);
     const chars = boxChars();
-    const title = opts.title ? ` ${opts.title} ` : "";
+    let title = opts.title ? ` ${opts.title} ` : "";
     const contentInner = Math.max(0, ...lines.map(visibleWidth), visibleWidth(title)) + padding * 2;
     let innerWidth = contentInner;
+    let body = lines;
     if (opts.width !== undefined) {
-        // outer = inner + 2 border cols
-        innerWidth = Math.max(contentInner, opts.width - 2);
+        // outer = inner + 2 border cols; clamp, never grow.
+        innerWidth = Math.max(0, opts.width - 2);
+        const contentCells = Math.max(0, innerWidth - padding * 2);
+        body = lines.map((line) => visibleWidth(line) > contentCells ? padVisible(line, contentCells) : line);
+        if (visibleWidth(title) > innerWidth)
+            title = sliceVisible(title, 0, innerWidth);
     }
     else if (opts.minWidth !== undefined) {
         innerWidth = Math.max(contentInner, opts.minWidth - 2);
@@ -63,37 +72,12 @@ export function roundedBox(lines, opts = {}) {
         ? `${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)}`;
+    const leftPad = Math.min(padding, innerWidth);
+    const rows = body.map((line) => {
+        const gap = Math.max(0, innerWidth - leftPad - visibleWidth(line));
+        return `${ansi.gray(chars.v)}${" ".repeat(leftPad)}${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);
+    return [top, ...rows, bottom];
 }
 /**
  * Join left/right columns into rows of equal left-column width.

package/dist/ui/findings.d.ts

@@ -1,11 +1,13 @@
 /** Shared review-job findings payload (API may send snake or camel for off-diff). */
 export type ReviewFindings = {
+    specialists_run?: string[];
     inline?: {
         path: string;
         line: number;
         severity: string;
         body: string;
         title?: string;
+        specialist?: string;
     }[];
     off_diff?: {
         path?: string;

package/dist/ui/findings.js

@@ -3,7 +3,8 @@ export function renderFindings(findings, opts = {}) {
     const inline = findings?.inline ?? [];
     const off = findings?.off_diff ?? findings?.offDiff ?? [];
     for (const c of inline) {
-        console.log(`\n[${c.severity}] ${c.path}:${c.line}${c.title ? ` — ${c.title}` : ""}`);
+        const lane = c.specialist ? `[${c.specialist}]` : "";
+        console.log(`\n[${c.severity}]${lane} ${c.path}:${c.line}${c.title ? ` — ${c.title}` : ""}`);
         console.log(c.body);
     }
     for (const c of off) {

package/dist/ui/job-envelope.d.ts

@@ -0,0 +1,68 @@
+import type { ReviewFindings } from "./findings.js";
+export declare const REVIEW_JOB_ENVELOPE_SCHEMA: "mergestorm.review_job/v1";
+export type ReviewJobRow = {
+    job_id?: string | null;
+    id?: string | null;
+    status?: string | null;
+    thread_slug?: string | null;
+    thread_job_number?: number | null;
+    base_label?: string | null;
+    head_label?: string | null;
+    router_mode?: string | null;
+    specialists_requested?: string[] | null;
+    specialists_run?: string[] | null;
+    verdict?: string | null;
+    summary?: string | null;
+    findings?: ReviewFindings | null;
+    truncated?: boolean | null;
+    error?: string | null;
+    credits?: {
+        standard: number;
+    } | null;
+    webhook_secret?: string | null;
+    created_at?: string | null;
+    finished_at?: string | null;
+    retry_after_seconds?: number | null;
+};
+export type ReviewJobEnvelope = {
+    schema: typeof REVIEW_JOB_ENVELOPE_SCHEMA;
+    job_id: string | null;
+    status: string;
+    thread: {
+        slug: string;
+        job_number: number | null;
+    } | null;
+    base_label: string | null;
+    head_label: string | null;
+    router_mode: string | null;
+    specialists_requested: string[];
+    specialists_run: string[];
+    verdict: string | null;
+    summary: string | null;
+    findings: ReviewFindings | null;
+    truncated: boolean;
+    error: string | null;
+    credits: {
+        standard: number;
+    } | null;
+    webhook_secret: string | null;
+    created_at: string | null;
+    finished_at: string | null;
+    retry_after_seconds?: number;
+};
+export type ReviewEnvelopeFallbacks = {
+    jobId?: string | null;
+    status?: string;
+    threadSlug?: string | null;
+    baseLabel?: string | null;
+    headLabel?: string | null;
+    routerMode?: string | null;
+    specialistsRequested?: string[];
+    error?: string | null;
+    retryAfterSeconds?: number | null;
+};
+/**
+ * Stable machine envelope shared by submit and terminal review output.
+ * Fields added by the API-envelope work are nullable until that API lands.
+ */
+export declare function toReviewJobEnvelope(row: ReviewJobRow | null | undefined, fallback?: ReviewEnvelopeFallbacks): ReviewJobEnvelope;

package/dist/ui/job-envelope.js

@@ -0,0 +1,35 @@
+export const REVIEW_JOB_ENVELOPE_SCHEMA = "mergestorm.review_job/v1";
+/**
+ * Stable machine envelope shared by submit and terminal review output.
+ * Fields added by the API-envelope work are nullable until that API lands.
+ */
+export function toReviewJobEnvelope(row, fallback = {}) {
+    const slug = row?.thread_slug ?? fallback.threadSlug ?? null;
+    const findings = row?.findings ?? null;
+    const retryAfter = fallback.retryAfterSeconds ?? row?.retry_after_seconds ?? undefined;
+    return {
+        schema: REVIEW_JOB_ENVELOPE_SCHEMA,
+        job_id: row?.job_id ?? row?.id ?? fallback.jobId ?? null,
+        status: row?.status ?? fallback.status ?? "failed",
+        thread: slug
+            ? { slug, job_number: row?.thread_job_number ?? null }
+            : null,
+        base_label: row?.base_label ?? fallback.baseLabel ?? null,
+        head_label: row?.head_label ?? fallback.headLabel ?? null,
+        router_mode: row?.router_mode ?? fallback.routerMode ?? null,
+        specialists_requested: row?.specialists_requested ?? fallback.specialistsRequested ?? [],
+        specialists_run: row?.specialists_run ?? findings?.specialists_run ?? [],
+        verdict: row?.verdict ?? null,
+        summary: row?.summary ?? null,
+        findings,
+        truncated: row?.truncated ?? false,
+        error: fallback.error !== undefined ? fallback.error : (row?.error ?? null),
+        credits: row?.credits ?? null,
+        webhook_secret: row?.webhook_secret ?? null,
+        created_at: row?.created_at ?? null,
+        finished_at: row?.finished_at ?? null,
+        ...(retryAfter != null && Number.isFinite(retryAfter)
+            ? { retry_after_seconds: retryAfter }
+            : {}),
+    };
+}

package/dist/ui/prompt.d.ts

@@ -1,16 +1,107 @@
 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;
 }
 /** 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;
+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. */
+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): {
+    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[];
+}
+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.