@h-rig/cli 0.0.6-alpha.82 → 0.0.6-alpha.84

package/dist/src/app-opentui/command-pty-host.d.ts

@@ -0,0 +1,62 @@
+export type CommandPtyHostStatus = "starting" | "running" | "exited" | "failed";
+export type CommandPtyHostSnapshot = {
+    readonly command: readonly string[];
+    readonly label: string;
+    readonly status: CommandPtyHostStatus;
+    readonly cols: number;
+    readonly rows: number;
+    readonly lines: readonly string[];
+    readonly message?: string;
+    readonly exitCode?: number;
+    readonly signal?: string | null;
+};
+type CommandPtyInput = string | Uint8Array<ArrayBufferLike> | BufferSource;
+export type CommandPtyHostOptions = {
+    readonly argv: readonly string[];
+    readonly projectRoot: string;
+    readonly cols: number;
+    readonly rows: number;
+    readonly label?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly onSnapshot?: (snapshot: CommandPtyHostSnapshot) => void;
+    readonly onExit?: (snapshot: CommandPtyHostSnapshot) => void;
+    readonly onError?: (error: unknown, snapshot: CommandPtyHostSnapshot) => void;
+};
+export declare function getActiveCommandHost(): CommandPtyHost | null;
+export declare function stopActiveCommandHost(reason?: string): void;
+export declare function startCommandPtyHost(options: CommandPtyHostOptions): Promise<CommandPtyHost>;
+export declare class CommandPtyHost {
+    private readonly argv;
+    private readonly projectRoot;
+    private readonly label;
+    private readonly env?;
+    private readonly onSnapshot?;
+    private readonly onExit?;
+    private readonly onError?;
+    private readonly terminal;
+    private readonly decoder;
+    private proc;
+    private pty;
+    private status;
+    private cols;
+    private rows;
+    private message;
+    private exitCode;
+    private signal;
+    private notifyTimer;
+    private _disposed;
+    constructor(options: CommandPtyHostOptions);
+    get disposed(): boolean;
+    get snapshot(): CommandPtyHostSnapshot;
+    start(): Promise<void>;
+    write(data: CommandPtyInput): void;
+    resize(cols: number, rows: number): void;
+    dispose(reason?: string, options?: {
+        readonly kill?: boolean;
+        readonly notify?: boolean;
+    }): void;
+    private handlePtyData;
+    private emitSnapshotSoon;
+    private createSnapshot;
+}
+export {};

package/dist/src/app-opentui/command-pty-host.js

@@ -0,0 +1,248 @@
+// @bun
+// packages/cli/src/app-opentui/command-pty-host.ts
+import { basename } from "path";
+import { fileURLToPath } from "url";
+import { Terminal as XtermTerminal } from "@xterm/headless";
+var MIN_COLS = 40;
+var MIN_ROWS = 10;
+var MAX_ROWS = 300;
+var MAX_SNAPSHOT_LINES = 420;
+var SNAPSHOT_DELAY_MS = 80;
+var fallbackCliScriptPath = fileURLToPath(new URL("../../bin/rig.ts", import.meta.url));
+var activeHost = null;
+function clampCols(cols) {
+  return Math.max(MIN_COLS, Math.trunc(cols || 120));
+}
+function clampRows(rows) {
+  return Math.max(MIN_ROWS, Math.min(MAX_ROWS, Math.trunc(rows || 36)));
+}
+function childCommandPrefix() {
+  const execName = basename(process.execPath).toLowerCase();
+  const currentEntry = process.argv[1];
+  if (execName === "bun" || execName === "bun.exe") {
+    return currentEntry ? [process.execPath, currentEntry] : [process.execPath, fallbackCliScriptPath];
+  }
+  return [process.execPath];
+}
+function withEnv(base) {
+  const env = {};
+  for (const [key, value] of Object.entries(base ?? process.env)) {
+    if (key === "NO_COLOR")
+      continue;
+    if (typeof value === "string")
+      env[key] = value;
+  }
+  return {
+    ...env,
+    TERM: "xterm-256color",
+    COLORTERM: "truecolor",
+    FORCE_COLOR: env.FORCE_COLOR ?? "1",
+    RIG_PLAIN: "1",
+    RIG_OPENTUI_COMMAND_HOST: "1",
+    RIG_CLI_PLAIN_HELP: env.RIG_CLI_PLAIN_HELP ?? "1"
+  };
+}
+function commandLabel(argv, fallback) {
+  const command = argv.join(" ").trim();
+  return fallback?.trim() || (command ? `rig ${command}` : "rig");
+}
+function getActiveCommandHost() {
+  return activeHost && !activeHost.disposed ? activeHost : null;
+}
+function stopActiveCommandHost(reason = "detach") {
+  activeHost?.dispose(reason);
+  activeHost = null;
+}
+async function startCommandPtyHost(options) {
+  activeHost?.dispose("replace");
+  const host = new CommandPtyHost(options);
+  activeHost = host;
+  await host.start();
+  return host;
+}
+
+class CommandPtyHost {
+  argv;
+  projectRoot;
+  label;
+  env;
+  onSnapshot;
+  onExit;
+  onError;
+  terminal;
+  decoder = new TextDecoder("utf-8");
+  proc = null;
+  pty = null;
+  status = "starting";
+  cols;
+  rows;
+  message = "starting command";
+  exitCode;
+  signal;
+  notifyTimer = null;
+  _disposed = false;
+  constructor(options) {
+    this.argv = [...options.argv];
+    this.projectRoot = options.projectRoot;
+    this.label = commandLabel(options.argv, options.label);
+    this.env = options.env;
+    this.cols = clampCols(options.cols);
+    this.rows = clampRows(options.rows);
+    this.onSnapshot = options.onSnapshot;
+    this.onExit = options.onExit;
+    this.onError = options.onError;
+    this.terminal = new XtermTerminal({ allowProposedApi: true, cols: this.cols, rows: this.rows, scrollback: 2000 });
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  get snapshot() {
+    return this.createSnapshot();
+  }
+  async start() {
+    if (this._disposed)
+      throw new Error("Command PTY host is disposed.");
+    if (typeof Bun.Terminal !== "function") {
+      throw new Error("Bun native PTY is unavailable in this runtime. Command host requires Bun.Terminal.");
+    }
+    const spawnOptions = {
+      cwd: this.projectRoot,
+      env: withEnv(this.env),
+      terminal: {
+        cols: this.cols,
+        rows: this.rows,
+        name: "xterm-256color",
+        data: (_terminal, data) => this.handlePtyData(data)
+      }
+    };
+    const proc = Bun.spawn([...childCommandPrefix(), ...this.argv], spawnOptions);
+    if (!proc.terminal)
+      throw new Error("Bun did not attach a terminal to the command child process.");
+    this.proc = proc;
+    this.pty = proc.terminal;
+    this.status = "running";
+    this.message = "running";
+    this.emitSnapshotSoon(0);
+    proc.exited.then((exitCode) => {
+      if (this._disposed)
+        return;
+      this.status = exitCode === 0 ? "exited" : "failed";
+      this.exitCode = exitCode;
+      this.signal = null;
+      this.message = exitCode === 0 ? "completed" : `exited with code ${exitCode}`;
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onExit?.(snapshot);
+      if (activeHost === this)
+        activeHost = null;
+      this.dispose("exit", { kill: false, notify: false });
+    }).catch((error) => {
+      if (this._disposed)
+        return;
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+      if (activeHost === this)
+        activeHost = null;
+      this.dispose("error", { kill: false, notify: false });
+    });
+  }
+  write(data) {
+    if (this._disposed || !this.pty)
+      return;
+    try {
+      this.pty.write(data);
+    } catch (error) {
+      this.status = "failed";
+      this.message = error instanceof Error ? error.message : String(error);
+      const snapshot = this.createSnapshot();
+      this.onSnapshot?.(snapshot);
+      this.onError?.(error, snapshot);
+    }
+  }
+  resize(cols, rows) {
+    const nextCols = clampCols(cols);
+    const nextRows = clampRows(rows);
+    if (nextCols === this.cols && nextRows === this.rows)
+      return;
+    this.cols = nextCols;
+    this.rows = nextRows;
+    this.terminal.resize(nextCols, nextRows);
+    try {
+      this.pty?.resize(nextCols, nextRows);
+    } catch {}
+    this.emitSnapshotSoon(0);
+  }
+  dispose(reason = "dispose", options = {}) {
+    if (this._disposed)
+      return;
+    this._disposed = true;
+    if (this.notifyTimer)
+      clearTimeout(this.notifyTimer);
+    this.notifyTimer = null;
+    if (options.kill !== false) {
+      try {
+        this.proc?.kill("SIGTERM");
+      } catch {}
+    }
+    try {
+      this.pty?.close();
+    } catch {}
+    try {
+      this.terminal.dispose();
+    } catch {}
+    if (activeHost === this)
+      activeHost = null;
+    if (options.notify) {
+      this.message = reason;
+      this.onSnapshot?.(this.createSnapshot(reason));
+    }
+  }
+  handlePtyData(data) {
+    if (this._disposed)
+      return;
+    this.decoder.decode(data, { stream: true });
+    this.terminal.write(data, () => this.emitSnapshotSoon());
+  }
+  emitSnapshotSoon(delayMs = SNAPSHOT_DELAY_MS) {
+    if (this._disposed || this.notifyTimer)
+      return;
+    this.notifyTimer = setTimeout(() => {
+      this.notifyTimer = null;
+      if (this._disposed)
+        return;
+      this.onSnapshot?.(this.createSnapshot());
+    }, delayMs);
+  }
+  createSnapshot(message = this.message) {
+    const buffer = this.terminal.buffer.active;
+    const end = buffer.length;
+    const start = Math.max(0, end - MAX_SNAPSHOT_LINES);
+    const lines = [];
+    for (let row = start;row < end; row += 1) {
+      const line = buffer.getLine(row);
+      lines.push((line?.translateToString(false) ?? "").slice(0, this.cols));
+    }
+    while (lines.length < this.rows)
+      lines.push("");
+    return {
+      command: this.argv,
+      label: this.label,
+      status: this.status,
+      cols: this.cols,
+      rows: this.rows,
+      lines,
+      message,
+      ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
+      ...this.signal !== undefined ? { signal: this.signal } : {}
+    };
+  }
+}
+export {
+  stopActiveCommandHost,
+  startCommandPtyHost,
+  getActiveCommandHost,
+  CommandPtyHost
+};

package/dist/src/app-opentui/drone.js

@@ -14,15 +14,17 @@ var RIG_UI = {
   bg: "#070809",
   bg2: "#0b0c0e",
   panel: "#101115",
-  panel2: "#101115",
-  glass: "#14161b",
-  ink: "#f2f3f6",
-  ink2: "#aeb0ba",
-  ink3: "#6c6e79",
-  ink4: "#44464f",
+  panel2: "#14161b",
+  glass: "#1e2230",
+  border: "#2a2e3a",
+  ink: "#f4f5f8",
+  ink2: "#c7c9d3",
+  ink3: "#9aa0ae",
+  ink4: "#787b86",
   lime: "#ccff4d",
   limeDim: "#a9d63f",
   cyan: "#56d8ff",
+  cyanDim: "#3f9fbd",
   red: "#ff5d5d",
   yellow: "#ffd24d",
   magenta: "#ff79b0"

package/dist/src/app-opentui/events.js

@@ -17,7 +17,7 @@ function normalizeError(error) {
   const message = error instanceof Error ? error.message : String(error);
   const rawHint = error instanceof Error ? error.hint : undefined;
   return {
-    message: message || "Unknown Rig app error",
+    message: message || "Unknown app error",
     ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {},
     cause: error
   };

package/dist/src/app-opentui/fleet-stats.d.ts

@@ -0,0 +1,32 @@
+import type { AppRunRecord } from "./adapters/fleet";
+import type { AppState } from "./types";
+export type FleetStats = {
+    readonly total: number;
+    readonly active: number;
+    readonly succeeded: number;
+    readonly failed: number;
+    readonly byStatus: ReadonlyMap<string, number>;
+    /** 0..1 fleet load: share of runs that are actively working. */
+    readonly load: number;
+    /** Recent activity series (oldest→newest) for a throughput sparkline. */
+    readonly sparkline: readonly number[];
+};
+/** Derive fleet telemetry from a run list. Pure — same input, same output. */
+export declare function computeFleetStats(runs: readonly AppRunRecord[]): FleetStats;
+export declare function fleetStatsFromState(state: AppState): FleetStats;
+/** Render a 0..1 series as a unicode sparkline string. */
+export declare function sparklineString(values: readonly number[], width?: number): string;
+/** Render a 0..1 ratio as a partial-block bar of `width` cells. */
+export declare function barString(ratio: number, width: number): string;
+export type StatusSegments = {
+    /** Block strings (█…) whose lengths are proportional to each class and sum to width. */
+    readonly active: string;
+    readonly done: string;
+    readonly failed: string;
+    readonly other: string;
+};
+/** Proportional status-distribution segments for a full-width stacked bar.
+ * Largest-remainder apportionment so the segments always sum to exactly `width`. */
+export declare function statusSegments(stats: FleetStats, width: number): StatusSegments;
+/** A compact one-line summary suitable for a scene header strip. */
+export declare function fleetStatsStrip(stats: FleetStats, sparkWidth?: number): string;

package/dist/src/app-opentui/fleet-stats.js

@@ -0,0 +1,114 @@
+// @bun
+// packages/cli/src/app-opentui/fleet-stats.ts
+var ACTIVE_STATUSES = new Set([
+  "running",
+  "preparing",
+  "created",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "stopping",
+  "loading"
+]);
+var SPARK_CHARS = ["\u2581", "\u2582", "\u2583", "\u2584", "\u2585", "\u2586", "\u2587", "\u2588"];
+var BAR_CHARS = ["\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589", "\u2588"];
+function normalizeStatus(status) {
+  return status.replace(/_/g, "-").toLowerCase();
+}
+function runsFromState(state) {
+  const fleet = state.data.fleet;
+  if (!fleet || typeof fleet !== "object" || Array.isArray(fleet))
+    return [];
+  const runs = fleet.runs;
+  return Array.isArray(runs) ? runs : [];
+}
+function computeFleetStats(runs) {
+  const byStatus = new Map;
+  let active = 0;
+  let succeeded = 0;
+  let failed = 0;
+  for (const run of runs) {
+    const status = normalizeStatus(run.status ?? "");
+    byStatus.set(status, (byStatus.get(status) ?? 0) + 1);
+    if (ACTIVE_STATUSES.has(status))
+      active += 1;
+    else if (status === "success" || status === "completed" || status === "merged")
+      succeeded += 1;
+    else if (status === "failed" || status === "error")
+      failed += 1;
+  }
+  const total = runs.length;
+  const load = total === 0 ? 0 : active / total;
+  const sparkline = buildSparklineSeries(active, succeeded, failed);
+  return { total, active, succeeded, failed, byStatus, load, sparkline };
+}
+function buildSparklineSeries(active, succeeded, failed) {
+  const peak = Math.max(1, active, succeeded, failed);
+  const base = [succeeded, Math.round(succeeded * 0.6 + failed * 0.4), failed, Math.round((active + failed) / 2), active];
+  return base.map((value) => Math.max(0, Math.min(peak, value)) / peak);
+}
+function fleetStatsFromState(state) {
+  return computeFleetStats(runsFromState(state));
+}
+function sparklineString(values, width) {
+  if (values.length === 0)
+    return "";
+  const series = width && width > 0 && values.length > width ? values.slice(values.length - width) : values;
+  return series.map((value) => {
+    const clamped = Math.max(0, Math.min(1, value));
+    const index = Math.min(SPARK_CHARS.length - 1, Math.round(clamped * (SPARK_CHARS.length - 1)));
+    return SPARK_CHARS[index];
+  }).join("");
+}
+function barString(ratio, width) {
+  if (width <= 0)
+    return "";
+  const clamped = Math.max(0, Math.min(1, ratio));
+  const totalEighths = Math.round(clamped * width * 8);
+  const full = Math.floor(totalEighths / 8);
+  const remainder = totalEighths % 8;
+  let bar = "\u2588".repeat(Math.min(width, full));
+  if (full < width && remainder > 0)
+    bar += BAR_CHARS[remainder - 1];
+  return bar.padEnd(width, " ").slice(0, width);
+}
+function statusSegments(stats, width) {
+  if (width <= 0 || stats.total === 0)
+    return { active: "", done: "", failed: "", other: "" };
+  const other = Math.max(0, stats.total - stats.active - stats.succeeded - stats.failed);
+  const raw = [
+    { key: "active", value: stats.active },
+    { key: "done", value: stats.succeeded },
+    { key: "failed", value: stats.failed },
+    { key: "other", value: other }
+  ];
+  const exact = raw.map((entry) => ({ key: entry.key, exact: entry.value / stats.total * width }));
+  const floored = exact.map((entry) => ({ key: entry.key, n: Math.floor(entry.exact), frac: entry.exact - Math.floor(entry.exact) }));
+  let remaining = width - floored.reduce((sum, entry) => sum + entry.n, 0);
+  for (const entry of [...floored].sort((a, b) => b.frac - a.frac)) {
+    if (remaining <= 0)
+      break;
+    entry.n += 1;
+    remaining -= 1;
+  }
+  const widths = new Map(floored.map((entry) => [entry.key, entry.n]));
+  return {
+    active: "\u2588".repeat(widths.get("active") ?? 0),
+    done: "\u2588".repeat(widths.get("done") ?? 0),
+    failed: "\u2588".repeat(widths.get("failed") ?? 0),
+    other: "\u2592".repeat(widths.get("other") ?? 0)
+  };
+}
+function fleetStatsStrip(stats, sparkWidth = 12) {
+  const spark = sparklineString(stats.sparkline, sparkWidth);
+  const loadPct = Math.round(stats.load * 100);
+  return `load ${spark} ${loadPct}%  \xB7  ${stats.active} active \xB7 ${stats.succeeded} done \xB7 ${stats.failed} failed \xB7 ${stats.total} total`;
+}
+export {
+  statusSegments,
+  sparklineString,
+  fleetStatsStrip,
+  fleetStatsFromState,
+  computeFleetStats,
+  barString
+};

package/dist/src/app-opentui/focus-manager.d.ts

@@ -0,0 +1,14 @@
+import type { TypeBarRenderables } from "./render/type-bar";
+export type AppModalState = {
+    readonly active: boolean;
+    readonly owner?: string;
+};
+export declare class AppFocusManager {
+    private modalStack;
+    pushModal(owner: string): void;
+    popModal(owner: string): void;
+    get modal(): AppModalState;
+    restoreTypeBarFocus(typeBar: TypeBarRenderables | null, options?: {
+        readonly hidden?: boolean;
+    }): void;
+}

package/dist/src/app-opentui/focus-manager.js

@@ -0,0 +1,24 @@
+// @bun
+// packages/cli/src/app-opentui/focus-manager.ts
+class AppFocusManager {
+  modalStack = [];
+  pushModal(owner) {
+    this.modalStack = [...this.modalStack.filter((entry) => entry !== owner), owner];
+  }
+  popModal(owner) {
+    this.modalStack = this.modalStack.filter((entry) => entry !== owner);
+  }
+  get modal() {
+    const owner = this.modalStack[this.modalStack.length - 1];
+    return owner ? { active: true, owner } : { active: false };
+  }
+  restoreTypeBarFocus(typeBar, options = {}) {
+    if (options.hidden || this.modal.active || !typeBar)
+      return;
+    if (!typeBar.input.focused)
+      typeBar.input.focus();
+  }
+}
+export {
+  AppFocusManager
+};